loop-agent-cli 0.1.0__py3-none-any.whl

app/services/dashboard.py

@@ -0,0 +1,230 @@
+from typing import Dict, Any, List
+from datetime import datetime, timedelta
+from app.repositories.position import PositionRepository
+from app.repositories.agent_run import AgentRunRepository
+from app.repositories.pipeline import PipelineRepository
+from app.repositories.candidate import CandidateRepository
+from app.repositories.node_log import NodeLogRepository
+from app.models.position import Position
+from app.models.agent_run import AgentRun
+from app.models.pipeline import Pipeline
+from app.models.candidate import Candidate
+from app.models.node_log import NodeLog
+import uuid
+
+
+class DashboardService:
+    """
+    Service for retrieving dashboard metrics and statistics
+    """
+    
+    def __init__(
+        self,
+        position_repo: PositionRepository,
+        agent_run_repo: AgentRunRepository,
+        pipeline_repo: PipelineRepository,
+        candidate_repo: CandidateRepository,
+        node_log_repo: NodeLogRepository
+    ):
+        self.position_repo = position_repo
+        self.agent_run_repo = agent_run_repo
+        self.pipeline_repo = pipeline_repo
+        self.candidate_repo = candidate_repo
+        self.node_log_repo = node_log_repo
+    
+    async def get_dashboard_summary(self) -> Dict[str, Any]:
+        """
+        Get the main dashboard summary metrics
+        """
+        # Get today's date for filtering
+        today_start = datetime.combine(datetime.today().date(), datetime.min.time())
+        
+        # Count running positions
+        active_positions = await self.position_repo.get_all(status="active")
+        running_positions_count = len(active_positions)
+        
+        # Count today's agent runs
+        all_runs = await self.agent_run_repo.get_all(skip=0, limit=1000)
+        today_runs = [run for run in all_runs if run.started_at.date() == datetime.today().date()]
+        today_loops = len(today_runs)
+        
+        # Count today's candidates
+        all_candidates = await self.candidate_repo.get_all(skip=0, limit=1000)
+        today_candidates = [cand for cand in all_candidates if cand.created_at.date() == datetime.today().date()]
+        today_candidates_count = len(today_candidates)
+        
+        # Count today's emails sent (from agent runs)
+        today_emails = sum(run.emails_sent for run in today_runs)
+        
+        # Count recent errors
+        recent_errors = [run for run in all_runs if run.error and run.started_at.date() == datetime.today().date()]
+        today_errors = len(recent_errors)
+        
+        # Count replies (candidates who have replied in pipeline)
+        replied_candidates = await self.pipeline_repo.get_by_status(None, "replied")  # This would need to be filtered by date in practice
+        
+        return {
+            "running_positions": running_positions_count,
+            "today_loops": today_loops,
+            "today_candidates": today_candidates_count,
+            "today_emails": today_emails,
+            "today_replies": len(replied_candidates),  # Placeholder
+            "today_errors": today_errors
+        }
+    
+    async def get_running_positions(self) -> List[Dict[str, Any]]:
+        """
+        Get information about currently running positions
+        """
+        active_positions = await self.position_repo.get_all(status="active")
+        result = []
+        
+        for pos in active_positions:
+            # Get recent pipeline stats for this position
+            pipelines = await self.pipeline_repo.get_by_position(pos.id, skip=0, limit=100)
+            
+            # Calculate stats
+            contacted_count = len([p for p in pipelines if p.status == "contacted"])
+            
+            result.append({
+                "id": pos.id,
+                "title": pos.title,
+                "company": pos.company,
+                "status": pos.status,
+                "last_loop_at": pos.last_loop_at,
+                "next_loop_at": pos.next_loop_at,
+                "candidate_count": len(pipelines),
+                "contacted_count": contacted_count
+            })
+        
+        return result
+    
+    async def get_recent_activity(self) -> List[Dict[str, Any]]:
+        """
+        Get recent activity timeline
+        """
+        # Get recent agent runs and node logs
+        recent_runs = await self.agent_run_repo.get_all(skip=0, limit=20)
+        recent_logs = await self.node_log_repo.get_all(skip=0, limit=50)
+        
+        activities = []
+        
+        # Add agent runs to activities
+        for run in recent_runs[-10:]:  # Last 10 runs
+            activities.append({
+                "time": run.started_at.strftime("%H:%M"),
+                "type": "loop",
+                "message": f"Loop completed for position {str(run.position_id)[:8]}",
+                "details": {
+                    "candidates_found": run.candidates_found,
+                    "candidates_added": run.candidates_added,
+                    "emails_sent": run.emails_sent
+                }
+            })
+        
+        # Add node logs to activities
+        for log in recent_logs[-10:]:  # Last 10 logs
+            activities.append({
+                "time": log.started_at.strftime("%H:%M"),
+                "type": log.node_name,
+                "message": f"{log.node_name.capitalize()} node executed",
+                "details": {
+                    "status": log.status,
+                    "duration_ms": log.duration_ms
+                }
+            })
+        
+        # Sort by time (most recent first)
+        activities.sort(key=lambda x: x["time"], reverse=True)
+        
+        return activities[:20]  # Return top 20
+    
+    async def get_recent_errors(self) -> List[Dict[str, Any]]:
+        """
+        Get recent errors from agent runs and node logs
+        """
+        all_runs = await self.agent_run_repo.get_all(skip=0, limit=100)
+        all_logs = await self.node_log_repo.get_all(skip=0, limit=100)
+        
+        errors = []
+        
+        # Get errors from agent runs
+        for run in all_runs:
+            if run.error:
+                errors.append({
+                    "time": run.started_at.strftime("%H:%M"),
+                    "source": "agent_run",
+                    "message": run.error,
+                    "position_id": str(run.position_id)
+                })
+        
+        # Get errors from node logs
+        for log in all_logs:
+            if log.error:
+                errors.append({
+                    "time": log.started_at.strftime("%H:%M"),
+                    "source": log.node_name,
+                    "message": log.error,
+                    "position_id": "unknown"  # Would need to trace back to position
+                })
+        
+        # Sort by time (most recent first)
+        errors.sort(key=lambda x: x["time"], reverse=True)
+        
+        return errors[:10]  # Return top 10
+    
+    async def get_position_stats(self, position_id: uuid.UUID) -> Dict[str, Any]:
+        """
+        Get detailed statistics for a specific position
+        """
+        position = await self.position_repo.get_by_id(position_id)
+        if not position:
+            return {}
+        
+        # Get pipelines for this position
+        pipelines = await self.pipeline_repo.get_by_position(position_id, skip=0, limit=1000)
+        
+        # Count by status
+        status_counts = {}
+        for pipeline in pipelines:
+            status = pipeline.status
+            status_counts[status] = status_counts.get(status, 0) + 1
+        
+        # Get related agent runs
+        runs = await self.agent_run_repo.get_by_position(position_id, skip=0, limit=100)
+        
+        # Calculate metrics
+        total_candidates = len(pipelines)
+        contacted_count = status_counts.get("contacted", 0)
+        replied_count = status_counts.get("replied", 0)
+        total_emails_sent = sum(run.emails_sent for run in runs)
+        
+        return {
+            "position": {
+                "id": position.id,
+                "title": position.title,
+                "company": position.company,
+                "status": position.status,
+                "created_at": position.created_at
+            },
+            "pipeline_stats": status_counts,
+            "metrics": {
+                "total_candidates": total_candidates,
+                "contacted": contacted_count,
+                "replied": replied_count,
+                "total_emails_sent": total_emails_sent,
+                "total_runs": len(runs)
+            },
+            "recent_runs": [
+                {
+                    "id": run.id,
+                    "started_at": run.started_at,
+                    "finished_at": run.finished_at,
+                    "duration_ms": run.duration_ms,
+                    "candidates_found": run.candidates_found,
+                    "candidates_added": run.candidates_added,
+                    "emails_sent": run.emails_sent,
+                    "status": run.status
+                } for run in runs[-5:]  # Last 5 runs
+            ]
+        }

app/services/email.py

@@ -0,0 +1,116 @@
+import smtplib
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+from app.core.config import settings
+from app.core.exceptions import SMTPException
+from app.repositories.outreach_log import OutreachLogRepository
+from app.models.outreach_log import OutreachLog
+from app.schemas.outreach_log import OutreachLogCreate
+import asyncio
+from typing import Optional
+import uuid
+
+
+class EmailService:
+    """
+    Service for sending emails to candidates
+    """
+    
+    def __init__(self, outreach_log_repo: OutreachLogRepository):
+        self.outreach_log_repo = outreach_log_repo
+        self.smtp_host = settings.smtp_host
+        self.smtp_user = settings.smtp_user
+        self.smtp_password = settings.smtp_password
+        self.smtp_port = settings.smtp_port
+        self.sender_email = settings.EMAIL_FROM
+    
+    async def send_email(self, recipient_email: str, subject: str, body: str, pipeline_id: uuid.UUID) -> bool:
+        """
+        Send an email to a candidate and log the result
+        """
+        # Create the outreach log entry
+        outreach_log_data = OutreachLogCreate(
+            pipeline_id=pipeline_id,
+            subject=subject,
+            body=body,
+            status="pending"
+        )
+        
+        outreach_log = await self.outreach_log_repo.create(outreach_log_data)
+        
+        try:
+            # Create message
+            msg = MIMEMultipart()
+            msg['From'] = self.sender_email
+            msg['To'] = recipient_email
+            msg['Subject'] = subject
+            
+            # Add body to email
+            msg.attach(MIMEText(body, 'html'))
+            
+            # Create SMTP session
+            server = smtplib.SMTP(self.smtp_host, self.smtp_port)
+            server.starttls()  # Enable encryption
+            server.login(self.smtp_user, self.smtp_password)
+            
+            # Send email
+            text = msg.as_string()
+            server.sendmail(self.sender_email, recipient_email, text)
+            server.quit()
+            
+            # Update outreach log status to sent
+            await self.outreach_log_repo.update_status(outreach_log.id, "sent")
+            
+            return True
+            
+        except Exception as e:
+            # Update outreach log status to failed
+            await self.outreach_log_repo.update_status_with_error(outreach_log.id, "failed", str(e))
+            raise SMTPException(f"Failed to send email: {str(e)}")
+    
+    async def send_bulk_emails(self, recipients: list, subject: str, body: str) -> dict:
+        """
+        Send bulk emails and return statistics
+        """
+        stats = {
+            "total": len(recipients),
+            "sent": 0,
+            "failed": 0
+        }
+        
+        for recipient in recipients:
+            try:
+                success = await self.send_email(recipient["email"], subject, body, recipient["pipeline_id"])
+                if success:
+                    stats["sent"] += 1
+                else:
+                    stats["failed"] += 1
+            except Exception:
+                stats["failed"] += 1
+                
+            # Small delay to avoid overwhelming the SMTP server
+            await asyncio.sleep(1)
+        
+        return stats
+    
+    def generate_email_template(self, candidate_name: str, position_title: str, company_name: str) -> str:
+        """
+        Generate a personalized email template
+        """
+        template = f"""
+        <html>
+        <body>
+            <p>Dear {candidate_name},</p>
+            
+            <p>I came across your profile on GitHub and noticed your expertise in technologies that align with our current opening for a {position_title} at {company_name}. Given your impressive contributions, I thought this opportunity might interest you.</p>
+            
+            <p>We are looking for someone with skills in {position_title.split()[0] if position_title else 'software development'} and would love to discuss how you could contribute to our team.</p>
+            
+            <p>Would you be interested in learning more about this opportunity?</p>
+            
+            <p>Best regards,<br/>
+            Recruiting Loop Agent</p>
+        </body>
+        </html>
+        """
+        return template

app/services/health.py

@@ -0,0 +1,105 @@
+from typing import Dict, Any
+from app.database.session import engine
+from sqlalchemy import text
+import httpx
+import asyncio
+from app.core.config import settings
+
+
+class HealthService:
+    """
+    Service for checking the health of various system components
+    """
+    
+    async def check_database(self) -> Dict[str, Any]:
+        """
+        Check database connectivity
+        """
+        try:
+            async with engine.begin() as conn:
+                await conn.execute(text("SELECT 1"))
+            return {"status": "connected", "message": "Database is accessible"}
+        except Exception as e:
+            return {"status": "error", "message": f"Database connection failed: {str(e)}"}
+    
+    async def check_scheduler(self) -> Dict[str, Any]:
+        """
+        Check scheduler status
+        """
+        # For now, just return a placeholder
+        # In a real implementation, this would check the actual scheduler status
+        return {"status": "running", "message": "Scheduler is operational"}
+    
+    async def check_github(self) -> Dict[str, Any]:
+        """
+        Check GitHub API connectivity
+        """
+        try:
+            if not settings.github_token:
+                return {"status": "warning", "message": "GitHub token not configured"}
+            
+            headers = {
+                "Authorization": f"token {settings.github_token}",
+                "Accept": "application/vnd.github.v3+json"
+            }
+            
+            async with httpx.AsyncClient() as client:
+                response = await client.get("https://api.github.com/user", headers=headers)
+                
+                if response.status_code == 200:
+                    return {"status": "connected", "message": "GitHub API is accessible"}
+                else:
+                    return {"status": "error", "message": f"GitHub API returned status {response.status_code}"}
+        except Exception as e:
+            return {"status": "error", "message": f"GitHub API connection failed: {str(e)}"}
+    
+    async def check_smtp(self) -> Dict[str, Any]:
+        """
+        Check SMTP connectivity
+        """
+        try:
+            if not settings.smtp_host or not settings.smtp_user or not settings.smtp_password:
+                return {"status": "warning", "message": "SMTP credentials not fully configured"}
+            
+            # For now, just check if the config is available
+            # In a real implementation, we'd try to connect to the SMTP server
+            return {"status": "configured", "message": "SMTP is configured"}
+        except Exception as e:
+            return {"status": "error", "message": f"SMTP configuration error: {str(e)}"}
+    
+    async def get_full_health_status(self) -> Dict[str, Any]:
+        """
+        Get comprehensive health status of all system components
+        """
+        # Run all health checks concurrently
+        db_task = self.check_database()
+        scheduler_task = self.check_scheduler()
+        github_task = self.check_github()
+        smtp_task = self.check_smtp()
+        
+        results = await asyncio.gather(
+            db_task, scheduler_task, github_task, smtp_task,
+            return_exceptions=True
+        )
+        
+        # Process results
+        health_status = {
+            "database": results[0] if not isinstance(results[0], Exception) else {"status": "error", "message": str(results[0])},
+            "scheduler": results[1] if not isinstance(results[1], Exception) else {"status": "error", "message": str(results[1])},
+            "github": results[2] if not isinstance(results[2], Exception) else {"status": "error", "message": str(results[2])},
+            "smtp": results[3] if not isinstance(results[3], Exception) else {"status": "error", "message": str(results[3])},
+        }
+        
+        # Determine overall status
+        overall_status = "healthy"
+        for component, status_info in health_status.items():
+            if status_info["status"] == "error":
+                overall_status = "error"
+                break
+            elif status_info["status"] == "warning" and overall_status != "error":
+                overall_status = "warning"
+        
+        health_status["overall"] = overall_status
+        health_status["timestamp"] = asyncio.get_event_loop().time()
+        
+        return health_status

app/services/pipeline.py

@@ -0,0 +1,75 @@
+from typing import List, Optional
+from app.repositories.pipeline import PipelineRepository
+from app.schemas.pipeline import PipelineCreate, PipelineUpdate, Pipeline
+from app.core.exceptions import PipelineNotFoundException
+import uuid
+
+class PipelineService:
+    def __init__(self, pipeline_repo: PipelineRepository):
+        self.pipeline_repo = pipeline_repo
+
+    async def create_pipeline(self, pipeline_data: PipelineCreate) -> Pipeline:
+        # Check if pipeline already exists for this position and candidate
+        existing_pipeline = await self.pipeline_repo.get_by_position_and_candidate(
+            pipeline_data.position_id,
+            pipeline_data.candidate_id
+        )
+        
+        if existing_pipeline:
+            # Return existing pipeline instead of creating duplicate
+            return existing_pipeline
+        
+        return await self.pipeline_repo.create(pipeline_data)
+
+    async def get_pipeline_by_id(self, pipeline_id: uuid.UUID) -> Pipeline:
+        pipeline = await self.pipeline_repo.get_by_id(pipeline_id)
+        if not pipeline:
+            raise PipelineNotFoundException(f"Pipeline with id {pipeline_id} not found")
+        return pipeline
+
+    async def get_pipeline_by_position_and_candidate(self, position_id: uuid.UUID, candidate_id: uuid.UUID) -> Optional[Pipeline]:
+        return await self.pipeline_repo.get_by_position_and_candidate(position_id, candidate_id)
+
+    async def get_pipelines_by_position(self, position_id: uuid.UUID, skip: int = 0, limit: int = 100) -> List[Pipeline]:
+        return await self.pipeline_repo.get_by_position(position_id, skip, limit)
+
+    async def get_pipelines_by_status(self, position_id: uuid.UUID, status: str) -> List[Pipeline]:
+        return await self.pipeline_repo.get_by_status(position_id, status)
+
+    async def get_all_pipelines(self, skip: int = 0, limit: int = 100) -> List[Pipeline]:
+        return await self.pipeline_repo.get_all(skip, limit)
+
+    async def update_pipeline(self, pipeline_id: uuid.UUID, pipeline_data: PipelineUpdate) -> Optional[Pipeline]:
+        return await self.pipeline_repo.update(pipeline_id, pipeline_data)
+
+    async def update_pipeline_status(self, pipeline_id: uuid.UUID, status: str) -> Optional[Pipeline]:
+        return await self.pipeline_repo.update_status(pipeline_id, status)
+
+    async def delete_pipeline(self, pipeline_id: uuid.UUID) -> bool:
+        return await self.pipeline_repo.delete(pipeline_id)
+
+    async def move_to_next_stage(self, pipeline_id: uuid.UUID) -> Optional[Pipeline]:
+        """
+        Move pipeline to the next stage in the recruitment process
+        discovered -> contacted -> replied -> interview -> offer -> rejected
+        """
+        pipeline = await self.get_pipeline_by_id(pipeline_id)
+        if pipeline:
+            current_status = pipeline.status
+            if current_status == "discovered":
+                next_status = "contacted"
+            elif current_status == "contacted":
+                next_status = "replied"
+            elif current_status == "replied":
+                next_status = "interview"
+            elif current_status == "interview":
+                next_status = "offer"
+            elif current_status == "offer":
+                next_status = "rejected"
+            else:
+                next_status = current_status
+            
+            if current_status != next_status:
+                return await self.update_pipeline_status(pipeline_id, next_status)
+        
+        return pipeline

app/services/position.py

@@ -0,0 +1,36 @@
+from typing import List, Optional
+from app.repositories.position import PositionRepository
+from app.schemas.position import PositionCreate, PositionUpdate, Position
+from app.core.exceptions import PositionNotFoundException
+import uuid
+
+class PositionService:
+    def __init__(self, position_repo: PositionRepository):
+        self.position_repo = position_repo
+
+    async def create_position(self, position_data: PositionCreate) -> Position:
+        return await self.position_repo.create(position_data)
+
+    async def get_position_by_id(self, position_id: uuid.UUID) -> Position:
+        position = await self.position_repo.get_by_id(position_id)
+        if not position:
+            raise PositionNotFoundException(f"Position with id {position_id} not found")
+        return position
+
+    async def get_all_positions(self, skip: int = 0, limit: int = 100, status: Optional[str] = None) -> List[Position]:
+        return await self.position_repo.get_all(skip, limit, status)
+
+    async def update_position(self, position_id: uuid.UUID, position_data: PositionUpdate) -> Optional[Position]:
+        return await self.position_repo.update(position_id, position_data)
+
+    async def delete_position(self, position_id: uuid.UUID) -> bool:
+        return await self.position_repo.delete(position_id)
+
+    async def pause_position(self, position_id: uuid.UUID) -> Optional[Position]:
+        return await self.position_repo.update_status(position_id, "paused")
+
+    async def resume_position(self, position_id: uuid.UUID) -> Optional[Position]:
+        return await self.position_repo.update_status(position_id, "active")
+
+    async def close_position(self, position_id: uuid.UUID) -> Optional[Position]:
+        return await self.position_repo.update_status(position_id, "closed")