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

app/agents/graph.py

@@ -0,0 +1,40 @@
+from langgraph.graph import StateGraph
+from app.agents.state import RecruitingState
+from app.agents.nodes import search_node, dedup_node, score_node, pipeline_node, outreach_node, evaluate_node
+
+
+def create_recruiting_graph():
+    """
+    Create the recruiting loop agent graph
+    """
+    workflow = StateGraph(RecruitingState)
+    
+    # Add nodes to the graph
+    workflow.add_node("search", search_node)
+    workflow.add_node("dedup", dedup_node)
+    workflow.add_node("score", score_node)
+    workflow.add_node("pipeline", pipeline_node)
+    workflow.add_node("outreach", outreach_node)
+    workflow.add_node("evaluate", evaluate_node)
+    
+    # Define the flow
+    workflow.set_entry_point("search")
+    workflow.add_edge("search", "dedup")
+    workflow.add_edge("dedup", "score")
+    workflow.add_edge("score", "pipeline")
+    workflow.add_edge("pipeline", "outreach")
+    workflow.add_edge("outreach", "evaluate")
+    
+    # The evaluate node decides whether to finish or loop back
+    # For now, we'll have it finish, but in a real implementation
+    # it might loop back to search based on conditions
+    workflow.add_conditional_edges(
+        "evaluate",
+        lambda x: "continue" if x.get("continue_loop", False) else "finish",
+        {
+            "continue": "search",  # Would loop back to search in a real implementation
+            "finish": "__end__"
+        }
+    )
+    
+    return workflow.compile()

app/agents/nodes.py

@@ -0,0 +1,245 @@
+from typing import Dict, Any, List
+from app.agents.state import RecruitingState
+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
+import asyncio
+
+
+async def search_node(state: RecruitingState) -> Dict[str, Any]:
+    """
+    Search node: Perform candidate search based on position requirements
+    """
+    try:
+        # This would integrate with the SearchService
+        position = state["position"]
+        
+        # Generate search keywords based on position requirements
+        keywords = [position.title] + (position.required_skills or []) + (position.search_keywords or [])
+        
+        # Simulate search (in real implementation, this would call SearchService)
+        # For now, return empty results as the actual search happens in RunnerService
+        search_results = {
+            "keywords": keywords,
+            "candidates": state.get("candidates", []),
+            "found_count": len(state.get("candidates", []))
+        }
+        
+        # Update metrics
+        metrics = state.get("metrics", {})
+        metrics["search_count"] = metrics.get("search_count", 0) + 1
+        
+        return {
+            **state,
+            "keywords": keywords,
+            "candidates": state.get("candidates", []),
+            "metrics": metrics
+        }
+    except Exception as e:
+        errors = state.get("errors", [])
+        errors.append(f"Search node error: {str(e)}")
+        
+        return {
+            **state,
+            "errors": errors
+        }
+
+
+async def dedup_node(state: RecruitingState) -> Dict[str, Any]:
+    """
+    Deduplication node: Remove duplicate candidates
+    """
+    try:
+        candidates = state.get("candidates", [])
+        
+        # In a real implementation, this would use CandidateService's deduplication methods
+        # For now, simulate deduplication by keeping unique candidates based on source_id
+        seen_ids = set()
+        unique_candidates = []
+        
+        for candidate in candidates:
+            # Extract source and source_id from candidate data
+            source_id = candidate.get("source_id") or (candidate.get("id") if hasattr(candidate, "id") else None)
+            if source_id not in seen_ids:
+                seen_ids.add(source_id)
+                unique_candidates.append(candidate)
+        
+        dedup_result = {
+            "original_count": len(candidates),
+            "unique_count": len(unique_candidates),
+            "duplicates_removed": len(candidates) - len(unique_candidates)
+        }
+        
+        # Update metrics
+        metrics = state.get("metrics", {})
+        metrics["candidates_deduped"] = len(unique_candidates)
+        
+        return {
+            **state,
+            "dedup_result": [unique_candidates],
+            "candidates": unique_candidates,
+            "metrics": metrics
+        }
+    except Exception as e:
+        errors = state.get("errors", [])
+        errors.append(f"Dedup node error: {str(e)}")
+        
+        return {
+            **state,
+            "errors": errors
+        }
+
+
+async def score_node(state: RecruitingState) -> Dict[str, Any]:
+    """
+    Scoring node: Score candidates based on position requirements
+    """
+    try:
+        candidates = state.get("candidates", [])
+        position = state["position"]
+        
+        # In a real implementation, this would use ScoreService
+        # For now, simulate scoring
+        scored_candidates = []
+        for candidate in candidates:
+            # Just add a dummy score for now - in real implementation, use ScoreService
+            candidate_with_score = {**candidate, "score": 75.0}  # Default score
+            scored_candidates.append(candidate_with_score)
+        
+        # Update metrics
+        metrics = state.get("metrics", {})
+        metrics["candidates_scored"] = len(scored_candidates)
+        
+        return {
+            **state,
+            "candidates": scored_candidates,
+            "metrics": metrics
+        }
+    except Exception as e:
+        errors = state.get("errors", [])
+        errors.append(f"Score node error: {str(e)}")
+        
+        return {
+            **state,
+            "errors": errors
+        }
+
+
+async def pipeline_node(state: RecruitingState) -> Dict[str, Any]:
+    """
+    Pipeline node: Update pipeline with scored candidates
+    """
+    try:
+        candidates = state.get("candidates", [])
+        position = state["position"]
+        
+        # In a real implementation, this would use PipelineService
+        # For now, simulate pipeline updates
+        pipeline_updates = []
+        for candidate in candidates:
+            # Create a simulated pipeline update
+            pipeline_update = {
+                "candidate_id": candidate.get("id", "unknown"),
+                "position_id": position.id,
+                "status": "discovered",
+                "score": candidate.get("score", 0)
+            }
+            pipeline_updates.append(pipeline_update)
+        
+        # Update metrics
+        metrics = state.get("metrics", {})
+        metrics["pipeline_updates"] = len(pipeline_updates)
+        
+        return {
+            **state,
+            "pipeline_updates": pipeline_updates,
+            "metrics": metrics
+        }
+    except Exception as e:
+        errors = state.get("errors", [])
+        errors.append(f"Pipeline node error: {str(e)}")
+        
+        return {
+            **state,
+            "errors": errors
+        }
+
+
+async def outreach_node(state: RecruitingState) -> Dict[str, Any]:
+    """
+    Outreach node: Send communications to candidates
+    """
+    try:
+        candidates = state.get("candidates", [])
+        position = state["position"]
+        
+        # In a real implementation, this would use EmailService
+        # For now, simulate outreach
+        outreach_results = []
+        for candidate in candidates[:5]:  # Only outreach to first 5 candidates
+            # Simulate email sending
+            outreach_result = {
+                "candidate_id": candidate.get("id", "unknown"),
+                "status": "sent",  # or "failed"
+                "type": "email"
+            }
+            outreach_results.append(outreach_result)
+        
+        # Update metrics
+        metrics = state.get("metrics", {})
+        metrics["outreach_attempts"] = len(outreach_results)
+        metrics["emails_sent"] = len(outreach_results)  # Assuming all attempts were successful
+        
+        return {
+            **state,
+            "metrics": metrics
+        }
+    except Exception as e:
+        errors = state.get("errors", [])
+        errors.append(f"Outreach node error: {str(e)}")
+        
+        return {
+            **state,
+            "errors": errors
+        }
+
+
+async def evaluate_node(state: RecruitingState) -> Dict[str, Any]:
+    """
+    Evaluation node: Decide whether to continue the loop
+    """
+    try:
+        position = state["position"]
+        
+        # Determine if the position is still open
+        # In a real implementation, this would check the position status
+        continue_loop = position.status == "active"
+        
+        # Update metrics
+        metrics = state.get("metrics", {})
+        metrics["evaluation_completed"] = True
+        
+        return {
+            **state,
+            "continue_loop": continue_loop,
+            "metrics": metrics
+        }
+    except Exception as e:
+        errors = state.get("errors", [])
+        errors.append(f"Evaluate node error: {str(e)}")
+        
+        return {
+            **state,
+            "errors": errors,
+            "continue_loop": False  # On error, stop the loop
+        }

app/agents/state.py

@@ -0,0 +1,19 @@
+from typing import TypedDict, List, Dict, Any, Optional
+from app.models.candidate import Candidate
+from app.models.position import Position
+import uuid
+
+
+class RecruitingState(TypedDict):
+    """
+    State for the recruiting loop agent
+    """
+    position: Position
+    keywords: List[str]
+    candidates: List[Dict[str, Any]]
+    dedup_result: List[Dict[str, Any]]
+    pipeline_updates: List[Dict[str, Any]]
+    metrics: Dict[str, int]
+    errors: List[str]
+    continue_loop: bool
+    run_id: Optional[uuid.UUID]

app/api/candidates.py

@@ -0,0 +1,49 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.database.session import get_db
+from app.services.candidate import CandidateService
+from app.repositories.candidate import CandidateRepository
+from app.schemas.candidate import CandidateCreate, CandidateUpdate, Candidate
+from typing import List
+import uuid
+
+router = APIRouter()
+
+@router.post("", response_model=Candidate)
+async def create_candidate(candidate: CandidateCreate, db: AsyncSession = Depends(get_db)):
+    repo = CandidateRepository(db)
+    service = CandidateService(repo)
+    return await service.create_candidate(candidate)
+
+@router.get("", response_model=List[Candidate])
+async def get_candidates(skip: int = 0, limit: int = 100, keyword: str = None, db: AsyncSession = Depends(get_db)):
+    repo = CandidateRepository(db)
+    service = CandidateService(repo)
+    return await service.get_all_candidates(skip=skip, limit=limit, keyword=keyword)
+
+@router.get("/{candidate_id}", response_model=Candidate)
+async def get_candidate(candidate_id: uuid.UUID, db: AsyncSession = Depends(get_db)):
+    repo = CandidateRepository(db)
+    service = CandidateService(repo)
+    try:
+        return await service.get_candidate_by_id(candidate_id)
+    except Exception as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+@router.put("/{candidate_id}", response_model=Candidate)
+async def update_candidate(candidate_id: uuid.UUID, candidate_update: CandidateUpdate, db: AsyncSession = Depends(get_db)):
+    repo = CandidateRepository(db)
+    service = CandidateService(repo)
+    updated_candidate = await service.update_candidate(candidate_id, candidate_update)
+    if not updated_candidate:
+        raise HTTPException(status_code=404, detail="Candidate not found")
+    return updated_candidate
+
+@router.delete("/{candidate_id}")
+async def delete_candidate(candidate_id: uuid.UUID, db: AsyncSession = Depends(get_db)):
+    repo = CandidateRepository(db)
+    service = CandidateService(repo)
+    success = await service.delete_candidate(candidate_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Candidate not found")
+    return {"message": "Candidate deleted successfully"}

app/api/dashboard.py

@@ -0,0 +1,7 @@
+from fastapi import APIRouter
+
+router = APIRouter()
+
+@router.get("/summary")
+async def get_dashboard_summary():
+    return {"running_positions": 0, "today_loops": 0, "today_candidates": 0, "today_emails": 0, "today_replies": 0, "today_errors": 0}

app/api/outreach.py

@@ -0,0 +1,7 @@
+from fastapi import APIRouter
+
+router = APIRouter()
+
+@router.get("/logs")
+async def get_outreach_logs():
+    return []

app/api/pipelines.py

@@ -0,0 +1,58 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.database.session import get_db
+from app.services.pipeline import PipelineService
+from app.repositories.pipeline import PipelineRepository
+from app.schemas.pipeline import PipelineCreate, PipelineUpdate, Pipeline
+from typing import List
+import uuid
+
+router = APIRouter()
+
+@router.post("", response_model=Pipeline)
+async def create_pipeline(pipeline: PipelineCreate, db: AsyncSession = Depends(get_db)):
+    repo = PipelineRepository(db)
+    service = PipelineService(repo)
+    return await service.create_pipeline(pipeline)
+
+@router.get("", response_model=List[Pipeline])
+async def get_pipelines(skip: int = 0, limit: int = 100, db: AsyncSession = Depends(get_db)):
+    repo = PipelineRepository(db)
+    service = PipelineService(repo)
+    return await service.get_all_pipelines(skip=skip, limit=limit)
+
+@router.get("/{pipeline_id}", response_model=Pipeline)
+async def get_pipeline_by_id(pipeline_id: uuid.UUID, db: AsyncSession = Depends(get_db)):
+    repo = PipelineRepository(db)
+    service = PipelineService(repo)
+    try:
+        return await service.get_pipeline_by_id(pipeline_id)
+    except Exception as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+@router.put("/{pipeline_id}", response_model=Pipeline)
+async def update_pipeline(pipeline_id: uuid.UUID, pipeline_update: PipelineUpdate, db: AsyncSession = Depends(get_db)):
+    repo = PipelineRepository(db)
+    service = PipelineService(repo)
+    updated_pipeline = await service.update_pipeline(pipeline_id, pipeline_update)
+    if not updated_pipeline:
+        raise HTTPException(status_code=404, detail="Pipeline not found")
+    return updated_pipeline
+
+@router.delete("/{pipeline_id}")
+async def delete_pipeline(pipeline_id: uuid.UUID, db: AsyncSession = Depends(get_db)):
+    repo = PipelineRepository(db)
+    service = PipelineService(repo)
+    success = await service.delete_pipeline(pipeline_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Pipeline not found")
+    return {"message": "Pipeline deleted successfully"}
+
+@router.put("/{pipeline_id}/status", response_model=Pipeline)
+async def update_pipeline_status(pipeline_id: uuid.UUID, status: str, db: AsyncSession = Depends(get_db)):
+    repo = PipelineRepository(db)
+    service = PipelineService(repo)
+    pipeline = await service.update_pipeline_status(pipeline_id, status)
+    if not pipeline:
+        raise HTTPException(status_code=404, detail="Pipeline not found")
+    return pipeline

app/api/positions.py

@@ -0,0 +1,76 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.database.session import get_db
+from app.services.position import PositionService
+from app.repositories.position import PositionRepository
+from app.schemas.position import PositionCreate, PositionUpdate, Position
+from typing import List
+import uuid
+
+router = APIRouter()
+
+@router.post("", response_model=Position)
+async def create_position(position: PositionCreate, db: AsyncSession = Depends(get_db)):
+    repo = PositionRepository(db)
+    service = PositionService(repo)
+    return await service.create_position(position)
+
+@router.get("", response_model=List[Position])
+async def get_positions(skip: int = 0, limit: int = 100, status: str = None, db: AsyncSession = Depends(get_db)):
+    repo = PositionRepository(db)
+    service = PositionService(repo)
+    return await service.get_all_positions(skip=skip, limit=limit, status=status)
+
+@router.get("/{position_id}", response_model=Position)
+async def get_position(position_id: uuid.UUID, db: AsyncSession = Depends(get_db)):
+    repo = PositionRepository(db)
+    service = PositionService(repo)
+    try:
+        return await service.get_position_by_id(position_id)
+    except Exception as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+@router.put("/{position_id}", response_model=Position)
+async def update_position(position_id: uuid.UUID, position_update: PositionUpdate, db: AsyncSession = Depends(get_db)):
+    repo = PositionRepository(db)
+    service = PositionService(repo)
+    updated_position = await service.update_position(position_id, position_update)
+    if not updated_position:
+        raise HTTPException(status_code=404, detail="Position not found")
+    return updated_position
+
+@router.delete("/{position_id}")
+async def delete_position(position_id: uuid.UUID, db: AsyncSession = Depends(get_db)):
+    repo = PositionRepository(db)
+    service = PositionService(repo)
+    success = await service.delete_position(position_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Position not found")
+    return {"message": "Position deleted successfully"}
+
+@router.post("/{position_id}/pause", response_model=Position)
+async def pause_position(position_id: uuid.UUID, db: AsyncSession = Depends(get_db)):
+    repo = PositionRepository(db)
+    service = PositionService(repo)
+    position = await service.pause_position(position_id)
+    if not position:
+        raise HTTPException(status_code=404, detail="Position not found")
+    return position
+
+@router.post("/{position_id}/resume", response_model=Position)
+async def resume_position(position_id: uuid.UUID, db: AsyncSession = Depends(get_db)):
+    repo = PositionRepository(db)
+    service = PositionService(repo)
+    position = await service.resume_position(position_id)
+    if not position:
+        raise HTTPException(status_code=404, detail="Position not found")
+    return position
+
+@router.post("/{position_id}/close", response_model=Position)
+async def close_position(position_id: uuid.UUID, db: AsyncSession = Depends(get_db)):
+    repo = PositionRepository(db)
+    service = PositionService(repo)
+    position = await service.close_position(position_id)
+    if not position:
+        raise HTTPException(status_code=404, detail="Position not found")
+    return position

app/api/router.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from app.api import dashboard, positions, candidates, pipelines, outreach, scheduler, skills, system
+
+router = APIRouter()
+
+# Include all API routers
+router.include_router(dashboard.router, prefix="/dashboard", tags=["dashboard"])
+router.include_router(positions.router, prefix="/positions", tags=["positions"])
+router.include_router(candidates.router, prefix="/candidates", tags=["candidates"])
+router.include_router(pipelines.router, prefix="/pipelines", tags=["pipelines"])
+router.include_router(outreach.router, prefix="/outreach", tags=["outreach"])
+router.include_router(scheduler.router, prefix="/scheduler", tags=["scheduler"])
+router.include_router(skills.router, prefix="/skills", tags=["skills"])
+router.include_router(system.router, prefix="/system", tags=["system"])

app/api/scheduler.py

@@ -0,0 +1,7 @@
+from fastapi import APIRouter
+
+router = APIRouter()
+
+@router.get("/jobs")
+async def get_scheduler_jobs():
+    return []

app/api/skills.py

@@ -0,0 +1,7 @@
+from fastapi import APIRouter
+
+router = APIRouter()
+
+@router.get("")
+async def get_skills():
+    return []

app/api/system.py

@@ -0,0 +1,7 @@
+from fastapi import APIRouter
+
+router = APIRouter()
+
+@router.get("/config")
+async def get_system_config():
+    return {}

app/core/config.py

@@ -0,0 +1,18 @@
+from pydantic_settings import BaseSettings
+from typing import Optional
+import os
+
+class Settings(BaseSettings):
+    database_url: str = "sqlite+aiosqlite:///./recruiting_agent.db"
+    debug: bool = False
+    github_token: Optional[str] = None
+    smtp_host: Optional[str] = None
+    smtp_user: Optional[str] = None
+    smtp_password: Optional[str] = None
+    smtp_port: int = 587
+    email_from: Optional[str] = None
+
+    class Config:
+        env_file = ".env"
+
+settings = Settings()

app/core/exception_handler.py

@@ -0,0 +1,91 @@
+from fastapi import Request, HTTPException
+from fastapi.responses import JSONResponse
+from app.core.exceptions import (
+    RecruitingAgentException,
+    PositionNotFoundException,
+    CandidateNotFoundException,
+    PipelineNotFoundException,
+    GitHubAPIException,
+    SMTPException,
+    DatabaseException
+)
+
+async def recruiting_agent_exception_handler(request: Request, exc: RecruitingAgentException):
+    return JSONResponse(
+        status_code=500,
+        content={
+            "success": False,
+            "message": str(exc),
+            "error_code": "INTERNAL_ERROR"
+        }
+    )
+
+async def position_not_found_exception_handler(request: Request, exc: PositionNotFoundException):
+    return JSONResponse(
+        status_code=404,
+        content={
+            "success": False,
+            "message": "Position not found",
+            "error_code": "POSITION_NOT_FOUND"
+        }
+    )
+
+async def candidate_not_found_exception_handler(request: Request, exc: CandidateNotFoundException):
+    return JSONResponse(
+        status_code=404,
+        content={
+            "success": False,
+            "message": "Candidate not found",
+            "error_code": "CANDIDATE_NOT_FOUND"
+        }
+    )
+
+async def pipeline_not_found_exception_handler(request: Request, exc: PipelineNotFoundException):
+    return JSONResponse(
+        status_code=404,
+        content={
+            "success": False,
+            "message": "Pipeline not found",
+            "error_code": "PIPELINE_NOT_FOUND"
+        }
+    )
+
+async def github_api_exception_handler(request: Request, exc: GitHubAPIException):
+    return JSONResponse(
+        status_code=500,
+        content={
+            "success": False,
+            "message": f"GitHub API Error: {str(exc)}",
+            "error_code": "GITHUB_API_ERROR"
+        }
+    )
+
+async def smtp_exception_handler(request: Request, exc: SMTPException):
+    return JSONResponse(
+        status_code=500,
+        content={
+            "success": False,
+            "message": f"SMTP Error: {str(exc)}",
+            "error_code": "SMTP_ERROR"
+        }
+    )
+
+async def database_exception_handler(request: Request, exc: DatabaseException):
+    return JSONResponse(
+        status_code=500,
+        content={
+            "success": False,
+            "message": f"Database Error: {str(exc)}",
+            "error_code": "DATABASE_ERROR"
+        }
+    )
+
+async def http_exception_handler(request: Request, exc: HTTPException):
+    return JSONResponse(
+        status_code=exc.status_code,
+        content={
+            "success": False,
+            "message": exc.detail,
+            "error_code": "HTTP_ERROR"
+        }
+    )