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

app/services/runner.py

@@ -0,0 +1,292 @@
+from typing import Dict, Any, List
+from app.services.search import SearchService
+from app.services.score import ScoreService
+from app.services.pipeline import PipelineService
+from app.services.email import EmailService
+from app.repositories.candidate import CandidateRepository
+from app.repositories.position import PositionRepository
+from app.repositories.pipeline import PipelineRepository
+from app.repositories.outreach_log import OutreachLogRepository
+from app.repositories.agent_run import AgentRunRepository
+from app.repositories.node_log import NodeLogRepository
+from app.models.candidate import Candidate
+from app.models.position import Position
+from app.models.pipeline import Pipeline
+from app.models.agent_run import AgentRun
+from app.models.node_log import NodeLog
+from app.schemas.agent_run import AgentRunCreate
+from app.schemas.node_log import NodeLogCreate
+from app.core.exceptions import DatabaseException
+from datetime import datetime
+import uuid
+import asyncio
+import time
+
+
+class RunnerService:
+    """
+    Service to coordinate the entire recruiting loop: Search -> Dedup -> Score -> Pipeline -> Outreach -> Evaluate
+    """
+    
+    def __init__(
+        self,
+        search_service: SearchService,
+        score_service: ScoreService,
+        pipeline_service: PipelineService,
+        email_service: EmailService,
+        candidate_repo: CandidateRepository,
+        position_repo: PositionRepository,
+        pipeline_repo: PipelineRepository,
+        outreach_log_repo: OutreachLogRepository,
+        agent_run_repo: AgentRunRepository,
+        node_log_repo: NodeLogRepository
+    ):
+        self.search_service = search_service
+        self.score_service = score_service
+        self.pipeline_service = pipeline_service
+        self.email_service = email_service
+        self.candidate_repo = candidate_repo
+        self.position_repo = position_repo
+        self.pipeline_repo = pipeline_repo
+        self.outreach_log_repo = outreach_log_repo
+        self.agent_run_repo = agent_run_repo
+        self.node_log_repo = node_log_repo
+    
+    async def run_recruiting_loop(self, position_id: uuid.UUID) -> Dict[str, Any]:
+        """
+        Execute the full recruiting loop for a position
+        """
+        start_time = time.time()
+        
+        # Create an agent run record
+        agent_run_data = AgentRunCreate(
+            position_id=position_id,
+            started_at=datetime.utcnow(),
+            status="running"
+        )
+        agent_run = await self.agent_run_repo.create(agent_run_data)
+        
+        try:
+            # Get position details
+            position = await self.position_repo.get_by_id(position_id)
+            if not position:
+                raise ValueError(f"Position {position_id} not found")
+            
+            # Prepare results tracking
+            results = {
+                "candidates_found": 0,
+                "candidates_added": 0,
+                "emails_sent": 0,
+                "errors": []
+            }
+            
+            # Node 1: Search
+            search_start = time.time()
+            try:
+                # Generate search keywords based on position requirements
+                keywords = await self.search_service.generate_search_keywords(
+                    position.title,
+                    position.required_skills or [],
+                    position.search_keywords or []
+                )
+                
+                # Search for candidates
+                candidates = await self.search_service.search_candidates(
+                    str(position_id),
+                    keywords,
+                    max_results=100
+                )
+                
+                results["candidates_found"] = len(candidates)
+                results["candidates"] = candidates
+                
+                # Log successful search
+                search_duration = time.time() - search_start
+                await self._log_node_result(agent_run.id, "search", "success", search_duration, {
+                    "keywords_used": keywords,
+                    "candidates_found": len(candidates)
+                })
+                
+            except Exception as e:
+                error_msg = f"Search failed: {str(e)}"
+                results["errors"].append(error_msg)
+                search_duration = time.time() - search_start
+                await self._log_node_result(agent_run.id, "search", "failed", search_duration, {
+                    "error": error_msg
+                })
+                # Continue with the rest of the loop despite search error
+            
+            # Node 2: Score (if candidates were found)
+            score_start = time.time()
+            try:
+                scored_candidates = []
+                if "candidates" in results:
+                    for candidate in results["candidates"]:
+                        # Calculate score for candidate
+                        score_result = await self.score_service.calculate_score(
+                            candidate,
+                            position.required_skills or []
+                        )
+                        
+                        # Check if candidate should be added to pipeline
+                        should_add = await self.score_service.should_add_to_pipeline(
+                            score_result["total_score"]
+                        )
+                        
+                        if should_add:
+                            # Create pipeline entry for candidate
+                            pipeline_data = {
+                                "position_id": position_id,
+                                "candidate_id": candidate.id,
+                                "score": score_result["total_score"],
+                                "score_detail": str(score_result["detail"]),
+                                "status": "discovered"
+                            }
+                            
+                            pipeline = await self.pipeline_service.create_pipeline(pipeline_data)
+                            scored_candidates.append({
+                                "candidate": candidate,
+                                "pipeline": pipeline,
+                                "score": score_result["total_score"]
+                            })
+                
+                results["scored_candidates"] = scored_candidates
+                
+                # Log successful scoring
+                score_duration = time.time() - score_start
+                await self._log_node_result(agent_run.id, "score", "success", score_duration, {
+                    "candidates_scored": len(results["scored_candidates"])
+                })
+                
+            except Exception as e:
+                error_msg = f"Scoring failed: {str(e)}"
+                results["errors"].append(error_msg)
+                score_duration = time.time() - score_start
+                await self._log_node_result(agent_run.id, "score", "failed", score_duration, {
+                    "error": error_msg
+                })
+            
+            # Node 3: Outreach (send emails to top candidates)
+            outreach_start = time.time()
+            try:
+                emails_sent = 0
+                if "scored_candidates" in results:
+                    # Sort candidates by score and send emails to top ones
+                    sorted_candidates = sorted(
+                        results["scored_candidates"],
+                        key=lambda x: x["score"],
+                        reverse=True
+                    )[:10]  # Top 10 candidates
+                    
+                    for item in sorted_candidates:
+                        candidate = item["candidate"]
+                        pipeline = item["pipeline"]
+                        
+                        # Generate and send email
+                        email_body = self.email_service.generate_email_template(
+                            candidate.name or candidate.github_login or "Candidate",
+                            position.title,
+                            position.company
+                        )
+                        
+                        if candidate.email:  # Only send if we have an email
+                            try:
+                                success = await self.email_service.send_email(
+                                    candidate.email,
+                                    f"Opportunity at {position.company}: {position.title}",
+                                    email_body,
+                                    pipeline.id
+                                )
+                                
+                                if success:
+                                    emails_sent += 1
+                                    
+                                    # Update pipeline status to contacted
+                                    await self.pipeline_service.update_pipeline_status(
+                                        pipeline.id,
+                                        "contacted"
+                                    )
+                            except Exception as email_error:
+                                error_msg = f"Email failed for candidate {candidate.id}: {str(email_error)}"
+                                results["errors"].append(error_msg)
+                
+                results["emails_sent"] = emails_sent
+                
+                # Log successful outreach
+                outreach_duration = time.time() - outreach_start
+                await self._log_node_result(agent_run.id, "outreach", "success", outreach_duration, {
+                    "emails_sent": emails_sent
+                })
+                
+            except Exception as e:
+                error_msg = f"Outreach failed: {str(e)}"
+                results["errors"].append(error_msg)
+                outreach_duration = time.time() - outreach_start
+                await self._log_node_result(agent_run.id, "outreach", "failed", outreach_duration, {
+                    "error": error_msg
+                })
+            
+            # Update results
+            results["candidates_added"] = len(results.get("scored_candidates", []))
+            results["emails_sent"] = results.get("emails_sent", 0)
+            
+            # Update agent run with final results
+            duration_ms = int((time.time() - start_time) * 1000)
+            await self.agent_run_repo.update_completion(
+                agent_run.id,
+                "success",
+                duration_ms,
+                results["candidates_found"],
+                results["candidates_added"],
+                results["emails_sent"]
+            )
+            
+            return {
+                "status": "completed",
+                "results": results,
+                "duration_ms": duration_ms
+            }
+            
+        except Exception as e:
+            # Handle critical error in the loop
+            duration_ms = int((time.time() - start_time) * 1000)
+            await self.agent_run_repo.update_completion(
+                agent_run.id,
+                "failed",
+                duration_ms,
+                0,
+                0,
+                0,
+                str(e)
+            )
+            
+            return {
+                "status": "failed",
+                "error": str(e),
+                "duration_ms": duration_ms
+            }
+    
+    async def _log_node_result(
+        self,
+        run_id: uuid.UUID,
+        node_name: str,
+        status: str,
+        duration: float,
+        data: Dict[str, Any]
+    ):
+        """
+        Log the result of a specific node in the recruiting loop
+        """
+        node_log_data = NodeLogCreate(
+            run_id=run_id,
+            node_name=node_name,
+            started_at=datetime.utcnow(),
+            finished_at=datetime.utcnow(),
+            duration_ms=int(duration * 1000),  # Convert to milliseconds
+            status=status,
+            input=str(data.get("input", {})),
+            output=str(data.get("output", {})),
+            error=data.get("error", "")
+        )
+        
+        await self.node_log_repo.create(node_log_data)

app/services/scheduler.py

@@ -0,0 +1,174 @@
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from apscheduler.triggers.interval import IntervalTrigger
+from datetime import datetime, timedelta
+from typing import Dict, Any, Optional
+import asyncio
+import uuid
+from app.repositories.position import PositionRepository
+from app.repositories.scheduler_job import SchedulerJobRepository
+from app.models.scheduler_job import SchedulerJob
+from app.services.runner import RunnerService
+
+
+class SchedulerService:
+    """
+    Service for managing the scheduling of recruiting loops
+    """
+    
+    def __init__(self, position_repo: PositionRepository, job_repo: SchedulerJobRepository, runner_service: RunnerService):
+        self.position_repo = position_repo
+        self.job_repo = job_repo
+        self.runner_service = runner_service
+        self.scheduler = AsyncIOScheduler()
+        
+    async def start(self):
+        """
+        Start the scheduler
+        """
+        if not self.scheduler.running:
+            self.scheduler.start()
+            
+            # Schedule periodic check for active positions
+            self.scheduler.add_job(
+                self._check_and_schedule_positions,
+                trigger=IntervalTrigger(seconds=60),  # Check every minute
+                id='position_checker',
+                name='Check positions for scheduling',
+                replace_existing=True
+            )
+    
+    async def stop(self):
+        """
+        Stop the scheduler
+        """
+        if self.scheduler.running:
+            self.scheduler.shutdown()
+    
+    async def schedule_position(self, position_id: uuid.UUID, interval_minutes: int = 60):
+        """
+        Schedule a position for recruiting loops
+        """
+        # Create or update scheduler job record
+        job_data = {
+            "position_id": position_id,
+            "enabled": True,
+            "interval_minutes": interval_minutes,
+            "next_run": datetime.utcnow() + timedelta(minutes=interval_minutes),
+            "status": "waiting"
+        }
+        
+        # Check if job already exists
+        existing_job = await self.job_repo.get_by_position_id(position_id)
+        if existing_job:
+            # Update existing job
+            await self.job_repo.update(existing_job.id, job_data)
+        else:
+            # Create new job
+            await self.job_repo.create(job_data)
+        
+        # Add job to scheduler
+        self.scheduler.add_job(
+            self._run_position_loop,
+            trigger=IntervalTrigger(minutes=interval_minutes),
+            id=f'position_{position_id}',
+            name=f'Run recruiting loop for position {position_id}',
+            args=[position_id],
+            replace_existing=True
+        )
+    
+    async def unschedule_position(self, position_id: uuid.UUID):
+        """
+        Remove a position from the scheduler
+        """
+        # Remove from scheduler
+        job_id = f'position_{position_id}'
+        if self.scheduler.get_job(job_id):
+            self.scheduler.remove_job(job_id)
+        
+        # Update job record
+        existing_job = await self.job_repo.get_by_position_id(position_id)
+        if existing_job:
+            await self.job_repo.update_status(position_id, "paused")
+    
+    async def _run_position_loop(self, position_id: uuid.UUID):
+        """
+        Internal method to run the recruiting loop for a position
+        """
+        try:
+            # Update job status to running
+            await self.job_repo.update_status(position_id, "running")
+            
+            # Run the recruiting loop
+            await self.runner_service.run_recruiting_loop(position_id)
+            
+            # Update job status to waiting
+            await self.job_repo.update_status(position_id, "waiting")
+            
+            # Update last run time
+            await self.job_repo.update_last_run(position_id, datetime.utcnow())
+            
+        except Exception as e:
+            # Update job status to error
+            await self.job_repo.update_status(position_id, "error")
+            print(f"Error running recruiting loop for position {position_id}: {str(e)}")
+    
+    async def _check_and_schedule_positions(self):
+        """
+        Internal method to periodically check for active positions and schedule them
+        """
+        # Get all active positions
+        positions = await self.position_repo.get_all(status="active")
+        
+        for position in positions:
+            # Check if position should be scheduled
+            if position.loop_enabled:
+                # Get existing job
+                existing_job = await self.job_repo.get_by_position_id(position.id)
+                
+                if not existing_job or existing_job.enabled:
+                    # Schedule the position if not already scheduled
+                    await self.schedule_position(position.id, position.loop_interval)
+    
+    async def get_job_status(self, position_id: uuid.UUID) -> Optional[Dict[str, Any]]:
+        """
+        Get the status of a scheduled job
+        """
+        job = await self.job_repo.get_by_position_id(position_id)
+        if not job:
+            return None
+        
+        scheduler_job = self.scheduler.get_job(f'position_{position_id}')
+        
+        return {
+            "position_id": job.position_id,
+            "enabled": job.enabled,
+            "interval_minutes": job.interval_minutes,
+            "next_run": job.next_run,
+            "last_run": job.last_run,
+            "total_runs": job.total_runs,
+            "status": job.status,
+            "scheduler_active": scheduler_job is not None
+        }
+    
+    async def pause_job(self, position_id: uuid.UUID):
+        """
+        Pause a scheduled job
+        """
+        await self.unschedule_position(position_id)
+        await self.job_repo.update_status(position_id, "paused")
+    
+    async def resume_job(self, position_id: uuid.UUID):
+        """
+        Resume a scheduled job
+        """
+        position = await self.position_repo.get_by_id(position_id)
+        if position:
+            await self.schedule_position(position_id, position.loop_interval)
+            await self.job_repo.update_status(position_id, "waiting")
+    
+    async def run_position_now(self, position_id: uuid.UUID):
+        """
+        Run a position's recruiting loop immediately
+        """
+        # Run the loop in the background
+        asyncio.create_task(self._run_position_loop(position_id))

app/services/score.py

@@ -0,0 +1,155 @@
+from typing import List, Dict, Any
+from app.models.candidate import Candidate
+from app.models.pipeline import Pipeline
+from app.schemas.pipeline import PipelineUpdate
+import json
+
+class ScoreService:
+    """
+    Service for calculating scores for candidates based on various factors
+    """
+    
+    def __init__(self):
+        # Weights for different scoring criteria
+        self.skill_weight = 0.5  # 50% of total score
+        self.activity_weight = 0.3  # 30% of total score
+        self.profile_weight = 0.2  # 20% of total score
+    
+    async def calculate_score(self, candidate: Candidate, required_skills: List[str]) -> Dict[str, Any]:
+        """
+        Calculate a score for a candidate based on required skills, activity, and profile completeness
+        """
+        # Calculate skill score (0-100)
+        skill_score = self._calculate_skill_score(candidate, required_skills)
+        
+        # Calculate activity score (0-100)
+        activity_score = self._calculate_activity_score(candidate)
+        
+        # Calculate profile score (0-100)
+        profile_score = self._calculate_profile_score(candidate)
+        
+        # Calculate weighted total score
+        total_score = (
+            skill_score * self.skill_weight +
+            activity_score * self.activity_weight +
+            profile_score * self.profile_weight
+        )
+        
+        score_detail = {
+            "skill_score": skill_score,
+            "activity_score": activity_score,
+            "profile_score": profile_score,
+            "weights": {
+                "skill": self.skill_weight,
+                "activity": self.activity_weight,
+                "profile": self.profile_weight
+            },
+            "breakdown": {
+                "skills_match": self._get_skills_match(candidate, required_skills)
+            }
+        }
+        
+        return {
+            "total_score": round(total_score, 2),
+            "detail": score_detail
+        }
+    
+    def _calculate_skill_score(self, candidate: Candidate, required_skills: List[str]) -> float:
+        """
+        Calculate skill-based score
+        """
+        if not required_skills or not candidate.skills:
+            return 0.0
+            
+        # Parse skills from JSON string if needed
+        candidate_skills_list = candidate.skills if isinstance(candidate.skills, list) else []
+        if isinstance(candidate.skills, str):
+            try:
+                candidate_skills_list = json.loads(candidate.skills)
+            except:
+                candidate_skills_list = []
+        
+        matched_skills = [skill for skill in required_skills if skill.lower() in [s.lower() for s in candidate_skills_list]]
+        score = (len(matched_skills) / len(required_skills)) * 100
+        
+        return min(score, 100.0)  # Cap at 100
+    
+    def _calculate_activity_score(self, candidate: Candidate) -> float:
+        """
+        Calculate activity-based score based on GitHub metrics
+        """
+        # Followers contribute up to 40 points
+        followers_score = min((candidate.followers / 100) * 40, 40)
+        
+        # Public repos contribute up to 30 points
+        repos_score = min((candidate.public_repos / 20) * 30, 30)
+        
+        # Combined activity score (max 70)
+        activity_score = followers_score + repos_score
+        
+        # Normalize to 0-100 scale
+        normalized_score = (activity_score / 70) * 100 if activity_score > 0 else 0
+        
+        return min(normalized_score, 100.0)
+    
+    def _calculate_profile_score(self, candidate: Candidate) -> float:
+        """
+        Calculate profile completeness score
+        """
+        score = 0
+        
+        # Name present
+        if candidate.name:
+            score += 15
+        
+        # Location present
+        if candidate.location:
+            score += 10
+            
+        # Company present
+        if candidate.company:
+            score += 10
+            
+        # Bio present
+        if candidate.bio:
+            score += 20
+            
+        # Profile URL present
+        if candidate.profile_url:
+            score += 15
+            
+        # Avatar URL present
+        if candidate.avatar_url:
+            score += 10
+            
+        # Email present
+        if candidate.email:
+            score += 20
+            
+        return min(score, 100.0)
+    
+    def _get_skills_match(self, candidate: Candidate, required_skills: List[str]) -> Dict[str, Any]:
+        """
+        Get details about skills match for reporting
+        """
+        candidate_skills_list = candidate.skills if isinstance(candidate.skills, list) else []
+        if isinstance(candidate.skills, str):
+            try:
+                candidate_skills_list = json.loads(candidate.skills)
+            except:
+                candidate_skills_list = []
+        
+        matched_skills = [skill for skill in required_skills if skill.lower() in [s.lower() for s in candidate_skills_list]]
+        unmatched_skills = [skill for skill in required_skills if skill.lower() not in [s.lower() for s in candidate_skills_list]]
+        
+        return {
+            "matched": matched_skills,
+            "unmatched": unmatched_skills,
+            "match_percentage": len(matched_skills) / len(required_skills) * 100 if required_skills else 0
+        }
+    
+    async def should_add_to_pipeline(self, score: float, threshold: float = 60.0) -> bool:
+        """
+        Determine if a candidate should be added to the pipeline based on score
+        """
+        return score >= threshold