@anastops/cli 1.0.0 → 1.2.0

package/ranger-tui/ranger_tui/data/client.py

@@ -0,0 +1,858 @@
+"""
+Data client for MongoDB and Redis connections.
+Provides all read/write operations for sessions, tasks, agents, and artifacts.
+"""
+
+import asyncio
+from datetime import datetime, UTC
+from typing import Optional, Any
+from motor.motor_asyncio import AsyncIOMotorClient, AsyncIOMotorDatabase
+import redis.asyncio as aioredis
+from nanoid import generate as nanoid
+
+from ranger_tui.config import config
+from .models import (
+    Session, Task, Agent, Artifact, SessionReport,
+    SessionMetadata, SessionStatistics, TaskStats,
+    TokenUsage, TaskInput, TaskOutput,
+)
+
+
+class DataClient:
+    """
+    Async data client for MongoDB and Redis.
+    Provides all operations matching the 40 MCP tools.
+    """
+    
+    def __init__(
+        self,
+        mongodb_url: Optional[str] = None,
+        redis_url: Optional[str] = None,
+    ):
+        self._mongodb_url = mongodb_url or config.mongodb_url
+        self._redis_url = redis_url or config.redis_url
+        self._mongo_client: Optional[AsyncIOMotorClient] = None
+        self._db: Optional[AsyncIOMotorDatabase] = None
+        self._redis: Optional[aioredis.Redis] = None
+        self._connected = False
+    
+    async def connect(self) -> bool:
+        """Connect to MongoDB and Redis."""
+        try:
+            # Connect to MongoDB
+            self._mongo_client = AsyncIOMotorClient(
+                self._mongodb_url,
+                serverSelectionTimeoutMS=5000,
+                connectTimeoutMS=5000,
+            )
+            self._db = self._mongo_client.anastops
+            
+            # Test MongoDB connection
+            await self._db.command("ping")
+            
+            # Connect to Redis
+            self._redis = aioredis.from_url(
+                self._redis_url,
+                decode_responses=True,
+            )
+            
+            # Test Redis connection
+            await self._redis.ping()
+            
+            self._connected = True
+            return True
+        except Exception as e:
+            self._connected = False
+            print(f"Connection error: {e}")
+            return False
+    
+    async def disconnect(self) -> None:
+        """Disconnect from databases."""
+        if self._mongo_client:
+            self._mongo_client.close()
+            self._mongo_client = None
+            self._db = None
+        if self._redis:
+            await self._redis.close()
+            self._redis = None
+        self._connected = False
+    
+    @property
+    def is_connected(self) -> bool:
+        """Check if connected to databases."""
+        return self._connected
+    
+    async def health_check(self) -> dict[str, Any]:
+        """Check health of MongoDB and Redis connections."""
+        result = {
+            "mongodb": False,
+            "redis": False,
+            "mongodb_error": None,
+            "redis_error": None,
+        }
+        
+        if self._db is not None:
+            try:
+                await self._db.command("ping")
+                result["mongodb"] = True
+            except Exception as e:
+                result["mongodb_error"] = str(e)
+        
+        if self._redis is not None:
+            try:
+                await self._redis.ping()
+                result["redis"] = True
+            except Exception as e:
+                result["redis_error"] = str(e)
+        
+        return result
+    
+    # ============ Session Operations ============
+    
+    async def get_sessions(
+        self,
+        status: Optional[str] = None,
+        limit: int = 100,
+    ) -> list[Session]:
+        """Get all sessions from MongoDB with task counts."""
+        if self._db is None:
+            return []
+        
+        query: dict[str, Any] = {}
+        if status:
+            query["status"] = status
+        
+        cursor = self._db.sessions.find(query).sort("updated_at", -1).limit(limit)
+        sessions = []
+        
+        async for doc in cursor:
+            sessions.append(self._doc_to_session(doc))
+        
+        # Fetch task counts for all sessions in one aggregation
+        if sessions:
+            session_ids = [s.id for s in sessions]
+            task_counts = await self._get_task_counts_by_session(session_ids)
+            
+            # Update session metadata with task counts
+            for session in sessions:
+                counts = task_counts.get(session.id, {})
+                session.metadata.tasks_total = counts.get("total", 0)
+                session.metadata.tasks_completed = counts.get("completed", 0)
+                session.metadata.tasks_failed = counts.get("failed", 0)
+                session.metadata.tasks_running = counts.get("running", 0)
+                session.metadata.tasks_pending = counts.get("pending", 0)
+                session.metadata.tasks_queued = counts.get("queued", 0)
+        
+        return sessions
+    
+    async def _get_task_counts_by_session(
+        self,
+        session_ids: list[str],
+    ) -> dict[str, dict[str, int]]:
+        """Get task counts grouped by session and status."""
+        if self._db is None:
+            return {}
+        
+        pipeline = [
+            {"$match": {"session_id": {"$in": session_ids}}},
+            {"$group": {
+                "_id": {"session_id": "$session_id", "status": "$status"},
+                "count": {"$sum": 1}
+            }},
+        ]
+        
+        result: dict[str, dict[str, int]] = {}
+        async for doc in self._db.tasks.aggregate(pipeline):
+            session_id = doc["_id"]["session_id"]
+            status = doc["_id"]["status"]
+            count = doc["count"]
+            
+            if session_id not in result:
+                result[session_id] = {"total": 0, "completed": 0, "failed": 0, "running": 0, "pending": 0, "queued": 0}
+            
+            result[session_id][status] = count
+            result[session_id]["total"] += count
+        
+        return result
+    
+    async def get_session(self, session_id: str) -> Optional[Session]:
+        """Get a single session by ID."""
+        if self._db is None:
+            return None
+        
+        doc = await self._db.sessions.find_one({"_id": session_id})
+        if doc:
+            return self._doc_to_session(doc)
+        return None
+    
+    async def create_session(self, objective: str) -> Session:
+        """Create a new session (session_spawn)."""
+        if self._db is None:
+            raise RuntimeError("Not connected to database")
+        
+        session_id = nanoid(12)
+        now = datetime.now(UTC)
+        
+        doc = {
+            "_id": session_id,
+            "id": session_id,
+            "user_id": "local",
+            "parent_session_id": None,
+            "fork_point": None,
+            "fork_reason": None,
+            "status": "active",
+            "objective": objective,
+            "created_at": now,
+            "updated_at": now,
+            "metadata": {
+                "total_tokens": 0,
+                "total_cost": 0,
+                "agents_used": [],
+                "files_affected": [],
+                "tasks_completed": 0,
+                "tasks_failed": 0,
+            },
+        }
+        
+        await self._db.sessions.insert_one(doc)
+        return self._doc_to_session(doc)
+    
+    async def archive_session(self, session_id: str) -> bool:
+        """Archive a session (session_archive)."""
+        if self._db is None:
+            return False
+        
+        result = await self._db.sessions.update_one(
+            {"_id": session_id},
+            {"$set": {"status": "archived", "updated_at": datetime.now(UTC)}}
+        )
+        return result.modified_count > 0
+    
+    async def purge_session(self, session_id: str) -> bool:
+        """Permanently delete a session and all related data (session_purge)."""
+        if self._db is None:
+            return False
+        
+        try:
+            await self._db.sessions.delete_one({"_id": session_id})
+            await self._db.tasks.delete_many({"session_id": session_id})
+            await self._db.agents.delete_many({"session_id": session_id})
+            await self._db.artifacts.delete_many({"session_id": session_id})
+            return True
+        except Exception:
+            return False
+    
+    async def purge_sessions_by_status(self, status: str) -> dict[str, Any]:
+        """Purge all sessions with a given status."""
+        if self._db is None:
+            return {"deleted_count": 0, "session_ids": []}
+        
+        # Get session IDs first
+        cursor = self._db.sessions.find({"status": status}, {"_id": 1})
+        session_ids = [doc["_id"] async for doc in cursor]
+        
+        if not session_ids:
+            return {"deleted_count": 0, "session_ids": []}
+        
+        # Delete related data
+        await self._db.tasks.delete_many({"session_id": {"$in": session_ids}})
+        await self._db.agents.delete_many({"session_id": {"$in": session_ids}})
+        await self._db.artifacts.delete_many({"session_id": {"$in": session_ids}})
+        
+        # Delete sessions
+        result = await self._db.sessions.delete_many({"_id": {"$in": session_ids}})
+        
+        return {
+            "deleted_count": result.deleted_count,
+            "session_ids": session_ids,
+        }
+    
+    async def fork_session(
+        self,
+        session_id: str,
+        reason: Optional[str] = None,
+    ) -> Optional[Session]:
+        """Fork a session (session_fork)."""
+        if self._db is None:
+            return None
+        
+        parent = await self.get_session(session_id)
+        if not parent:
+            return None
+        
+        fork_id = nanoid(12)
+        now = datetime.now(UTC)
+        
+        doc = {
+            "_id": fork_id,
+            "id": fork_id,
+            "user_id": parent.user_id,
+            "parent_session_id": session_id,
+            "fork_point": 0,
+            "fork_reason": reason,
+            "status": "active",
+            "objective": parent.objective,
+            "created_at": now,
+            "updated_at": now,
+            "metadata": parent.metadata.model_dump(),
+        }
+        
+        await self._db.sessions.insert_one(doc)
+        return self._doc_to_session(doc)
+    
+    async def get_session_report(self, session_id: str) -> Optional[SessionReport]:
+        """Get comprehensive session report (session_report)."""
+        session = await self.get_session(session_id)
+        if not session:
+            return None
+        
+        tasks = await self.get_tasks(session_id)
+        agents = await self.get_agents(session_id)
+        artifacts = await self.get_artifacts(session_id)
+        
+        # Calculate statistics
+        task_stats = TaskStats(
+            total=len(tasks),
+            pending=sum(1 for t in tasks if t.status == "pending"),
+            queued=sum(1 for t in tasks if t.status == "queued"),
+            running=sum(1 for t in tasks if t.status == "running"),
+            completed=sum(1 for t in tasks if t.status == "completed"),
+            failed=sum(1 for t in tasks if t.status == "failed"),
+            cancelled=sum(1 for t in tasks if t.status == "cancelled"),
+        )
+        
+        total_tokens = sum(t.token_usage.total_tokens for t in tasks)
+        total_cost = sum(t.token_usage.cost for t in tasks)
+        
+        statistics = SessionStatistics(
+            tasks=task_stats,
+            total_tokens=total_tokens,
+            total_cost_usd=total_cost,
+            agents_count=len(agents),
+            artifacts_count=len(artifacts),
+        )
+        
+        return SessionReport(
+            session=session,
+            statistics=statistics,
+            tasks=tasks,
+            agents=agents,
+            artifacts=artifacts,
+        )
+    
+    # ============ Task Operations ============
+    
+    async def get_tasks(
+        self,
+        session_id: Optional[str] = None,
+        status: Optional[str] = None,
+        limit: int = 100,
+    ) -> list[Task]:
+        """Get tasks from MongoDB."""
+        if self._db is None:
+            return []
+        
+        query: dict[str, Any] = {}
+        if session_id:
+            query["session_id"] = session_id
+        if status:
+            query["status"] = status
+        
+        cursor = self._db.tasks.find(query).sort("created_at", -1).limit(limit)
+        tasks = []
+        
+        async for doc in cursor:
+            tasks.append(self._doc_to_task(doc))
+        
+        return tasks
+    
+    async def get_task(self, task_id: str) -> Optional[Task]:
+        """Get a single task by ID."""
+        if self._db is None:
+            return None
+        
+        doc = await self._db.tasks.find_one({"_id": task_id})
+        if doc:
+            return self._doc_to_task(doc)
+        return None
+    
+    async def create_task(
+        self,
+        session_id: str,
+        task_type: str,
+        description: str,
+        prompt: str,
+        provider: str = "claude",
+        model: str = "claude-sonnet",
+    ) -> Task:
+        """Create a new task (task_create)."""
+        if self._db is None:
+            raise RuntimeError("Not connected to database")
+        
+        task_id = nanoid(12)
+        now = datetime.now(UTC)
+        
+        doc = {
+            "_id": task_id,
+            "id": task_id,
+            "session_id": session_id,
+            "agent_id": None,
+            "type": task_type,
+            "status": "pending",
+            "description": description,
+            "input": {"prompt": prompt, "context_files": []},
+            "output": None,
+            "error": None,
+            "complexity_score": 0,
+            "routing_tier": 3,
+            "provider": provider,
+            "model": model,
+            "token_usage": {
+                "prompt_tokens": 0,
+                "completion_tokens": 0,
+                "total_tokens": 0,
+                "cost": 0,
+            },
+            "created_at": now,
+            "started_at": None,
+            "completed_at": None,
+            "dependencies": [],
+            "priority": 5,
+            "retry_count": 0,
+            "max_retries": 3,
+        }
+        
+        await self._db.tasks.insert_one(doc)
+        return self._doc_to_task(doc)
+    
+    async def cancel_task(self, task_id: str) -> bool:
+        """Cancel a task (task_cancel)."""
+        if self._db is None:
+            return False
+        
+        result = await self._db.tasks.update_one(
+            {"_id": task_id, "status": {"$in": ["pending", "queued", "running"]}},
+            {"$set": {"status": "cancelled", "completed_at": datetime.now(UTC)}}
+        )
+        return result.modified_count > 0
+    
+    async def retry_task(self, task_id: str) -> bool:
+        """Retry a failed task (task_retry)."""
+        if self._db is None:
+            return False
+        
+        result = await self._db.tasks.update_one(
+            {"_id": task_id, "status": "failed"},
+            {
+                "$set": {
+                    "status": "pending",
+                    "error": None,
+                    "started_at": None,
+                    "completed_at": None,
+                },
+                "$inc": {"retry_count": 1},
+            }
+        )
+        return result.modified_count > 0
+    
+    async def queue_task(self, task_id: str) -> bool:
+        """Queue a task for execution (task_queue)."""
+        if self._db is None:
+            return False
+        
+        result = await self._db.tasks.update_one(
+            {"_id": task_id, "status": "pending"},
+            {"$set": {"status": "queued"}}
+        )
+        return result.modified_count > 0
+    
+    async def complete_task(
+        self,
+        task_id: str,
+        content: str,
+        artifacts: Optional[list[str]] = None,
+    ) -> bool:
+        """Mark a task as completed (task_complete)."""
+        if self._db is None:
+            return False
+        
+        result = await self._db.tasks.update_one(
+            {"_id": task_id},
+            {
+                "$set": {
+                    "status": "completed",
+                    "completed_at": datetime.now(UTC),
+                    "output": {
+                        "content": content,
+                        "artifacts": artifacts or [],
+                        "files_modified": [],
+                        "metadata": {},
+                    },
+                }
+            }
+        )
+        return result.modified_count > 0
+    
+    # ============ Agent Operations ============
+    
+    async def get_agents(
+        self,
+        session_id: Optional[str] = None,
+        status: Optional[str] = None,
+        limit: int = 100,
+    ) -> list[Agent]:
+        """Get agents from MongoDB."""
+        if self._db is None:
+            return []
+        
+        query: dict[str, Any] = {}
+        if session_id:
+            query["session_id"] = session_id
+        if status:
+            query["status"] = status
+        
+        cursor = self._db.agents.find(query).sort("created_at", -1).limit(limit)
+        agents = []
+        
+        async for doc in cursor:
+            agents.append(self._doc_to_agent(doc))
+        
+        return agents
+    
+    async def get_agent(self, agent_id: str) -> Optional[Agent]:
+        """Get a single agent by ID."""
+        if self._db is None:
+            return None
+        
+        doc = await self._db.agents.find_one({"_id": agent_id})
+        if doc:
+            return self._doc_to_agent(doc)
+        return None
+    
+    async def create_agent(
+        self,
+        session_id: str,
+        role: str,
+        name: Optional[str] = None,
+        provider: str = "claude",
+        model: str = "claude-sonnet",
+    ) -> Agent:
+        """Create a new agent (agent_create)."""
+        if self._db is None:
+            raise RuntimeError("Not connected to database")
+        
+        agent_id = nanoid(12)
+        now = datetime.now(UTC)
+        
+        doc = {
+            "_id": agent_id,
+            "id": agent_id,
+            "session_id": session_id,
+            "role": role,
+            "name": name or f"agent-{agent_id[:4]}",
+            "status": "idle",
+            "provider": provider,
+            "model": model,
+            "current_task_id": None,
+            "tasks_completed": 0,
+            "tasks_failed": 0,
+            "tokens_used": 0,
+            "created_at": now,
+            "last_activity_at": now,
+            "config": {},
+        }
+        
+        await self._db.agents.insert_one(doc)
+        return self._doc_to_agent(doc)
+    
+    async def deploy_agent(self, agent_id: str, task_id: str) -> bool:
+        """Deploy an agent to a task (agent_deploy)."""
+        if self._db is None:
+            return False
+        
+        result = await self._db.agents.update_one(
+            {"_id": agent_id},
+            {
+                "$set": {
+                    "current_task_id": task_id,
+                    "status": "working",
+                    "last_activity_at": datetime.now(UTC),
+                }
+            }
+        )
+        return result.modified_count > 0
+    
+    async def retire_agent(self, agent_id: str) -> bool:
+        """Retire an agent (agent_retire)."""
+        if self._db is None:
+            return False
+        
+        result = await self._db.agents.update_one(
+            {"_id": agent_id},
+            {
+                "$set": {
+                    "status": "completed",
+                    "current_task_id": None,
+                    "last_activity_at": datetime.now(UTC),
+                }
+            }
+        )
+        return result.modified_count > 0
+    
+    # ============ Artifact Operations ============
+    
+    async def get_artifacts(
+        self,
+        session_id: Optional[str] = None,
+        task_id: Optional[str] = None,
+        limit: int = 100,
+    ) -> list[Artifact]:
+        """Get artifacts from MongoDB."""
+        if self._db is None:
+            return []
+        
+        query: dict[str, Any] = {}
+        if session_id:
+            query["session_id"] = session_id
+        if task_id:
+            query["task_id"] = task_id
+        
+        cursor = self._db.artifacts.find(query).sort("created_at", -1).limit(limit)
+        artifacts = []
+        
+        async for doc in cursor:
+            artifacts.append(self._doc_to_artifact(doc))
+        
+        return artifacts
+    
+    async def save_artifact(
+        self,
+        session_id: str,
+        artifact_type: str,
+        name: str,
+        content: str,
+    ) -> Artifact:
+        """Save an artifact (artifact_save)."""
+        if self._db is None:
+            raise RuntimeError("Not connected to database")
+        
+        artifact_id = nanoid(12)
+        now = datetime.now(UTC)
+        
+        doc = {
+            "_id": artifact_id,
+            "id": artifact_id,
+            "session_id": session_id,
+            "task_id": None,
+            "type": artifact_type,
+            "name": name,
+            "extension": "",
+            "content": content,
+            "content_hash": "",
+            "size_bytes": len(content),
+            "summary": content[:200],
+            "token_count": len(content) // 4,
+            "relevance_score": 50,
+            "metadata": {},
+            "created_at": now,
+            "updated_at": now,
+        }
+        
+        await self._db.artifacts.insert_one(doc)
+        return self._doc_to_artifact(doc)
+    
+    # ============ Metrics Operations ============
+    
+    async def get_session_cost(self, session_id: str) -> dict[str, Any]:
+        """Get session cost breakdown (session_cost)."""
+        tasks = await self.get_tasks(session_id)
+        total_cost = sum(t.token_usage.cost for t in tasks)
+        
+        return {
+            "session_id": session_id,
+            "total_cost_usd": total_cost,
+            "currency": "USD",
+        }
+    
+    async def get_session_metrics(self, session_id: str) -> dict[str, Any]:
+        """Get session metrics (session_metrics)."""
+        tasks = await self.get_tasks(session_id)
+        
+        input_tokens = sum(t.token_usage.prompt_tokens for t in tasks)
+        output_tokens = sum(t.token_usage.completion_tokens for t in tasks)
+        total_tokens = sum(t.token_usage.total_tokens for t in tasks)
+        
+        return {
+            "session_id": session_id,
+            "request_count": len(tasks),
+            "token_usage": {
+                "input": input_tokens,
+                "output": output_tokens,
+                "total": total_tokens,
+            },
+        }
+    
+    # ============ Redis Operations ============
+    
+    async def get_active_session_count(self) -> int:
+        """Get count of active sessions from Redis."""
+        if self._redis is None:
+            return 0
+        
+        try:
+            keys = await self._redis.keys("session:*:status")
+            count = 0
+            for key in keys:
+                status = await self._redis.get(key)
+                if status == "active":
+                    count += 1
+            return count
+        except Exception:
+            return 0
+    
+    async def get_running_task_count(self) -> int:
+        """Get count of running tasks from Redis."""
+        if self._redis is None:
+            return 0
+        
+        try:
+            keys = await self._redis.keys("task:*:status")
+            count = 0
+            for key in keys:
+                status = await self._redis.get(key)
+                if status == "running":
+                    count += 1
+            return count
+        except Exception:
+            return 0
+    
+    # ============ Document Converters ============
+    
+    def _doc_to_session(self, doc: dict[str, Any]) -> Session:
+        """Convert MongoDB document to Session model."""
+        metadata_doc = doc.get("metadata", {})
+        metadata = SessionMetadata(
+            total_tokens=metadata_doc.get("total_tokens", 0),
+            total_cost=metadata_doc.get("total_cost", 0),
+            agents_used=metadata_doc.get("agents_used", []),
+            files_affected=metadata_doc.get("files_affected", []),
+            tasks_completed=metadata_doc.get("tasks_completed", 0),
+            tasks_failed=metadata_doc.get("tasks_failed", 0),
+        )
+        
+        return Session(
+            id=doc.get("id", doc.get("_id")),
+            user_id=doc.get("user_id", "local"),
+            parent_session_id=doc.get("parent_session_id"),
+            fork_point=doc.get("fork_point"),
+            fork_reason=doc.get("fork_reason"),
+            status=doc.get("status", "active"),
+            objective=doc.get("objective", ""),
+            created_at=doc.get("created_at", datetime.now(UTC)),
+            updated_at=doc.get("updated_at", datetime.now(UTC)),
+            metadata=metadata,
+        )
+    
+    def _doc_to_task(self, doc: dict[str, Any]) -> Task:
+        """Convert MongoDB document to Task model."""
+        input_doc = doc.get("input", {})
+        task_input = TaskInput(
+            prompt=input_doc.get("prompt", ""),
+            context_files=input_doc.get("context_files", []),
+            agent=input_doc.get("agent"),
+            skills=input_doc.get("skills", []),
+        )
+        
+        output_doc = doc.get("output")
+        task_output = None
+        if output_doc:
+            task_output = TaskOutput(
+                content=output_doc.get("content", ""),
+                artifacts=output_doc.get("artifacts", []),
+                files_modified=output_doc.get("files_modified", []),
+                metadata=output_doc.get("metadata", {}),
+            )
+        
+        token_doc = doc.get("token_usage", {})
+        token_usage = TokenUsage(
+            prompt_tokens=token_doc.get("prompt_tokens", 0),
+            completion_tokens=token_doc.get("completion_tokens", 0),
+            total_tokens=token_doc.get("total_tokens", 0),
+            cost=token_doc.get("cost", 0),
+        )
+        
+        return Task(
+            id=doc.get("id", doc.get("_id")),
+            session_id=doc.get("session_id", ""),
+            agent_id=doc.get("agent_id"),
+            type=doc.get("type", "other"),
+            status=doc.get("status", "pending"),
+            description=doc.get("description", ""),
+            input=task_input,
+            output=task_output,
+            error=doc.get("error"),
+            complexity_score=doc.get("complexity_score", 0),
+            routing_tier=doc.get("routing_tier", 3),
+            provider=doc.get("provider", "claude"),
+            model=doc.get("model", "claude-sonnet"),
+            token_usage=token_usage,
+            created_at=doc.get("created_at", datetime.now(UTC)),
+            started_at=doc.get("started_at"),
+            completed_at=doc.get("completed_at"),
+            dependencies=doc.get("dependencies", []),
+            priority=doc.get("priority", 5),
+            retry_count=doc.get("retry_count", 0),
+            max_retries=doc.get("max_retries", 3),
+            logs=doc.get("logs"),
+        )
+    
+    def _doc_to_agent(self, doc: dict[str, Any]) -> Agent:
+        """Convert MongoDB document to Agent model."""
+        return Agent(
+            id=doc.get("id", doc.get("_id")),
+            session_id=doc.get("session_id", ""),
+            role=doc.get("role", "implementer"),
+            name=doc.get("name", ""),
+            status=doc.get("status", "idle"),
+            provider=doc.get("provider", "claude"),
+            model=doc.get("model", "claude-sonnet"),
+            current_task_id=doc.get("current_task_id"),
+            tasks_completed=doc.get("tasks_completed", 0),
+            tasks_failed=doc.get("tasks_failed", 0),
+            tokens_used=doc.get("tokens_used", 0),
+            created_at=doc.get("created_at", datetime.now(UTC)),
+            last_activity_at=doc.get("last_activity_at", datetime.now(UTC)),
+            config=doc.get("config", {}),
+        )
+    
+    def _doc_to_artifact(self, doc: dict[str, Any]) -> Artifact:
+        """Convert MongoDB document to Artifact model."""
+        return Artifact(
+            id=doc.get("id", doc.get("_id")),
+            session_id=doc.get("session_id", ""),
+            task_id=doc.get("task_id"),
+            type=doc.get("type", "other"),
+            name=doc.get("name", ""),
+            extension=doc.get("extension", ""),
+            content=doc.get("content", ""),
+            content_hash=doc.get("content_hash", ""),
+            size_bytes=doc.get("size_bytes", 0),
+            summary=doc.get("summary", ""),
+            token_count=doc.get("token_count", 0),
+            relevance_score=doc.get("relevance_score", 50),
+            metadata=doc.get("metadata", {}),
+            created_at=doc.get("created_at", datetime.now(UTC)),
+            updated_at=doc.get("updated_at", datetime.now(UTC)),
+        )
+
+
+# Singleton instance
+_client_instance: Optional[DataClient] = None
+
+
+def get_client() -> DataClient:
+    """Get or create the singleton DataClient instance."""
+    global _client_instance
+    if _client_instance is None:
+        _client_instance = DataClient()
+    return _client_instance