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

app/core/exceptions.py

@@ -0,0 +1,33 @@
+class RecruitingAgentException(Exception):
+    """Base exception for Recruiting Loop Agent"""
+    pass
+
+
+class PositionNotFoundException(RecruitingAgentException):
+    """Raised when a position is not found"""
+    pass
+
+
+class CandidateNotFoundException(RecruitingAgentException):
+    """Raised when a candidate is not found"""
+    pass
+
+
+class PipelineNotFoundException(RecruitingAgentException):
+    """Raised when a pipeline is not found"""
+    pass
+
+
+class GitHubAPIException(RecruitingAgentException):
+    """Raised when GitHub API returns an error"""
+    pass
+
+
+class SMTPException(RecruitingAgentException):
+    """Raised when SMTP operations fail"""
+    pass
+
+
+class DatabaseException(RecruitingAgentException):
+    """Raised when database operations fail"""
+    pass

app/core/logging.py

@@ -0,0 +1,19 @@
+import logging
+import sys
+from pathlib import Path
+
+# Create logs directory if it doesn't exist
+log_dir = Path("logs")
+log_dir.mkdir(exist_ok=True)
+
+# Configure logger
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    handlers=[
+        logging.FileHandler(log_dir / "app.log"),
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+
+logger = logging.getLogger("recruiting_agent")

app/database/base.py

@@ -0,0 +1,4 @@
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import DeclarativeMeta
+
+Base: DeclarativeMeta = declarative_base()

app/database/session.py

@@ -0,0 +1,20 @@
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+from app.core.config import settings
+
+# Create async database engine
+engine = create_async_engine(
+    settings.database_url,
+    echo=True,  # Set to True for SQL query logging in debug mode
+    pool_pre_ping=True,
+    pool_recycle=300,
+)
+
+# Create async session maker
+from sqlalchemy.orm import sessionmaker
+AsyncSessionLocal = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
+
+
+async def get_db():
+    """Dependency for getting database session"""
+    async with AsyncSessionLocal() as session:
+        yield session

app/main.py

@@ -0,0 +1,72 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from app.api.router import router
+import uvicorn
+from app.core.exception_handler import (
+    recruiting_agent_exception_handler,
+    position_not_found_exception_handler,
+    candidate_not_found_exception_handler,
+    pipeline_not_found_exception_handler,
+    github_api_exception_handler,
+    smtp_exception_handler,
+    database_exception_handler,
+    http_exception_handler
+)
+from app.core.exceptions import (
+    RecruitingAgentException,
+    PositionNotFoundException,
+    CandidateNotFoundException,
+    PipelineNotFoundException,
+    GitHubAPIException,
+    SMTPException,
+    DatabaseException
+)
+from fastapi import HTTPException
+from app.database.base import Base
+from app.database.session import engine
+
+app = FastAPI(
+    title="Recruiting Loop Agent",
+    description="An autonomous recruiting agent that continuously searches for candidates",
+    version="3.0.0",
+    redirect_slashes=False
+)
+
+# CORS middleware - allow frontend requests
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:3000", "http://127.0.0.1:3000"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Register exception handlers
+app.add_exception_handler(RecruitingAgentException, recruiting_agent_exception_handler)
+app.add_exception_handler(PositionNotFoundException, position_not_found_exception_handler)
+app.add_exception_handler(CandidateNotFoundException, candidate_not_found_exception_handler)
+app.add_exception_handler(PipelineNotFoundException, pipeline_not_found_exception_handler)
+app.add_exception_handler(GitHubAPIException, github_api_exception_handler)
+app.add_exception_handler(SMTPException, smtp_exception_handler)
+app.add_exception_handler(DatabaseException, database_exception_handler)
+app.add_exception_handler(HTTPException, http_exception_handler)
+
+# Include API routes
+app.include_router(router, prefix="/api/v1")
+
+@app.get("/")
+async def root():
+    return {"message": "Recruiting Loop Agent is running!"}
+
+@app.get("/health")
+async def health_check():
+    return {"status": "ok"}
+
+# Create database tables on startup
+@app.on_event("startup")
+async def startup():
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000)

app/models/agent_run.py

@@ -0,0 +1,18 @@
+from sqlalchemy import Column, String, Text, Integer, DateTime
+from app.database.base import Base
+from datetime import datetime
+import uuid
+
+class AgentRun(Base):
+    __tablename__ = "agent_runs"
+
+    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
+    position_id = Column(String)  # Foreign key to positions table
+    started_at = Column(DateTime, default=datetime.utcnow)
+    finished_at = Column(DateTime)
+    duration_ms = Column(Integer)  # Duration in milliseconds
+    candidates_found = Column(Integer, default=0)
+    candidates_added = Column(Integer, default=0)
+    emails_sent = Column(Integer, default=0)
+    status = Column(String, default="running")  # running, success, failed
+    error = Column(Text)  # Error message if failed

app/models/candidate.py

@@ -0,0 +1,28 @@
+from sqlalchemy import Column, String, Text, Integer, Boolean, DateTime, Float
+from app.database.base import Base
+from datetime import datetime
+import uuid
+
+class Candidate(Base):
+    __tablename__ = "candidates"
+
+    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
+    source = Column(String, nullable=False)  # github, linkedin, etc
+    source_id = Column(String, nullable=False)  # GitHub user ID
+    github_login = Column(String)  # GitHub username
+    name = Column(String)
+    email = Column(String)
+    location = Column(String)
+    company = Column(String)
+    title = Column(String)
+    bio = Column(Text)
+    followers = Column(Integer, default=0)
+    public_repos = Column(Integer, default=0)
+    skills = Column(Text)  # Stored as JSON string
+    profile_url = Column(String)
+    avatar_url = Column(String)
+    search_keywords = Column(Text)  # Stored as JSON string
+    appearance_count = Column(Integer, default=1)
+    source_weight = Column(Float, default=1.0)  # Weight based on how often they appear
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)

app/models/node_log.py

@@ -0,0 +1,18 @@
+from sqlalchemy import Column, String, Text, Integer, DateTime
+from app.database.base import Base
+from datetime import datetime
+import uuid
+
+class NodeLog(Base):
+    __tablename__ = "node_logs"
+
+    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
+    run_id = Column(String)  # Foreign key to agent_runs table
+    node_name = Column(String)  # search, dedup, score, outreach, evaluate
+    started_at = Column(DateTime, default=datetime.utcnow)
+    finished_at = Column(DateTime)
+    duration_ms = Column(Integer)  # Duration in milliseconds
+    status = Column(String)  # success, failed
+    input = Column(Text)  # Input data as JSON string
+    output = Column(Text)  # Output data as JSON string
+    error = Column(Text)  # Error message if failed

app/models/outreach_log.py

@@ -0,0 +1,16 @@
+from sqlalchemy import Column, String, Text, Integer, DateTime
+from app.database.base import Base
+from datetime import datetime
+import uuid
+
+class OutreachLog(Base):
+    __tablename__ = "outreach_logs"
+
+    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
+    pipeline_id = Column(String)  # Foreign key to pipelines table
+    subject = Column(String)
+    body = Column(Text)
+    status = Column(String, default="pending")  # pending, sent, failed
+    error = Column(Text)  # Error message if failed
+    sent_at = Column(DateTime)
+    created_at = Column(DateTime, default=datetime.utcnow)

app/models/pipeline.py

@@ -0,0 +1,21 @@
+from sqlalchemy import Column, String, Text, Integer, DateTime, Float
+from app.database.base import Base
+from datetime import datetime
+import uuid
+
+class Pipeline(Base):
+    __tablename__ = "pipelines"
+
+    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
+    position_id = Column(String)  # Foreign key to positions table
+    candidate_id = Column(String)  # Foreign key to candidates table
+    status = Column(String, default="discovered")  # discovered, contacted, replied, interview, offer, rejected
+    score = Column(Float, default=0.0)  # Calculated score
+    score_detail = Column(Text)  # Detailed score breakdown as JSON string
+    contact_count = Column(Integer, default=0)
+    last_contacted_at = Column(DateTime)
+    next_followup_at = Column(DateTime)
+    candidate_interest = Column(String)  # high, medium, low
+    notes = Column(Text)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)

app/models/position.py

@@ -0,0 +1,22 @@
+from sqlalchemy import Column, String, Text, Integer, Boolean, DateTime
+from app.database.base import Base
+from datetime import datetime
+import uuid
+
+class Position(Base):
+    __tablename__ = "positions"
+
+    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
+    title = Column(String, nullable=False)
+    company = Column(String, nullable=False)
+    description = Column(Text)
+    location = Column(String)
+    required_skills = Column(Text)  # Stored as JSON string
+    search_keywords = Column(Text)  # Stored as JSON string
+    status = Column(String, default="active")  # active, paused, closed
+    loop_interval = Column(Integer, default=60)  # minutes
+    loop_enabled = Column(Boolean, default=True)
+    last_loop_at = Column(DateTime)
+    next_loop_at = Column(DateTime)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)

app/models/scheduler_job.py

@@ -0,0 +1,16 @@
+from sqlalchemy import Column, String, Text, Integer, Boolean, DateTime
+from app.database.base import Base
+from datetime import datetime
+import uuid
+
+class SchedulerJob(Base):
+    __tablename__ = "scheduler_jobs"
+
+    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
+    position_id = Column(String)  # Foreign key to positions table
+    enabled = Column(Boolean, default=True)
+    interval_minutes = Column(Integer, default=60)
+    next_run = Column(DateTime)
+    last_run = Column(DateTime)
+    total_runs = Column(Integer, default=0)
+    status = Column(String, default="waiting")  # waiting, running, paused

app/models/skill.py

@@ -0,0 +1,13 @@
+from sqlalchemy import Column, String, Text, Boolean, DateTime
+from app.database.base import Base
+from datetime import datetime
+import uuid
+
+class Skill(Base):
+    __tablename__ = "skills"
+
+    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
+    name = Column(String, nullable=False)  # github_search, linkedin_search, etc
+    description = Column(Text)
+    enabled = Column(Boolean, default=True)
+    created_at = Column(DateTime, default=datetime.utcnow)

app/models/system_config.py

@@ -0,0 +1,12 @@
+from sqlalchemy import Column, String, Text, DateTime
+from app.database.base import Base
+from datetime import datetime
+import uuid
+
+class SystemConfig(Base):
+    __tablename__ = "system_configs"
+
+    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
+    key = Column(String, nullable=False)  # SMTP_HOST, GITHUB_TOKEN, etc
+    value = Column(Text)  # Configuration value
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)

app/repositories/agent_run.py

@@ -0,0 +1,74 @@
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.future import select
+from app.models.agent_run import AgentRun
+from app.schemas.agent_run import AgentRunCreate, AgentRunUpdate
+from typing import List, Optional
+import uuid
+from datetime import datetime
+
+class AgentRunRepository:
+    def __init__(self, db_session: AsyncSession):
+        self.db_session = db_session
+
+    async def create(self, agent_run_data: AgentRunCreate) -> AgentRun:
+        db_agent_run = AgentRun(**agent_run_data.model_dump())
+        self.db_session.add(db_agent_run)
+        await self.db_session.commit()
+        await self.db_session.refresh(db_agent_run)
+        return db_agent_run
+
+    async def get_by_id(self, agent_run_id: uuid.UUID) -> Optional[AgentRun]:
+        stmt = select(AgentRun).where(AgentRun.id == agent_run_id)
+        result = await self.db_session.execute(stmt)
+        return result.scalar_one_or_none()
+
+    async def get_by_position(self, position_id: uuid.UUID, skip: int = 0, limit: int = 100) -> List[AgentRun]:
+        stmt = select(AgentRun).where(AgentRun.position_id == position_id).offset(skip).limit(limit)
+        result = await self.db_session.execute(stmt)
+        return result.scalars().all()
+
+    async def get_all(self, skip: int = 0, limit: int = 100) -> List[AgentRun]:
+        stmt = select(AgentRun).offset(skip).limit(limit)
+        result = await self.db_session.execute(stmt)
+        return result.scalars().all()
+
+    async def update(self, agent_run_id: uuid.UUID, agent_run_data: AgentRunUpdate) -> Optional[AgentRun]:
+        db_agent_run = await self.get_by_id(agent_run_id)
+        if db_agent_run:
+            for field, value in agent_run_data.model_dump(exclude_unset=True).items():
+                setattr(db_agent_run, field, value)
+            await self.db_session.commit()
+            await self.db_session.refresh(db_agent_run)
+        return db_agent_run
+
+    async def update_completion(
+        self,
+        agent_run_id: uuid.UUID,
+        status: str,
+        duration_ms: int,
+        candidates_found: int,
+        candidates_added: int,
+        emails_sent: int,
+        error: str = None
+    ) -> Optional[AgentRun]:
+        db_agent_run = await self.get_by_id(agent_run_id)
+        if db_agent_run:
+            db_agent_run.status = status
+            db_agent_run.duration_ms = duration_ms
+            db_agent_run.finished_at = datetime.utcnow()
+            db_agent_run.candidates_found = candidates_found
+            db_agent_run.candidates_added = candidates_added
+            db_agent_run.emails_sent = emails_sent
+            if error:
+                db_agent_run.error = error
+            await self.db_session.commit()
+            await self.db_session.refresh(db_agent_run)
+        return db_agent_run
+
+    async def delete(self, agent_run_id: uuid.UUID) -> bool:
+        db_agent_run = await self.get_by_id(agent_run_id)
+        if db_agent_run:
+            await self.db_session.delete(db_agent_run)
+            await self.db_session.commit()
+            return True
+        return False

app/repositories/candidate.py

@@ -0,0 +1,84 @@
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.future import select
+from app.models.candidate import Candidate
+from app.schemas.candidate import CandidateCreate, CandidateUpdate
+from typing import List, Optional
+import json
+import uuid
+
+
+def _serialize_candidate_data(data: dict) -> dict:
+    """Serialize list fields to JSON strings for database storage."""
+    for field in ("skills", "search_keywords"):
+        if field in data and data[field] is not None:
+            data[field] = json.dumps(data[field])
+    return data
+
+class CandidateRepository:
+    def __init__(self, db_session: AsyncSession):
+        self.db_session = db_session
+
+    async def create(self, candidate_data: CandidateCreate) -> Candidate:
+        data = _serialize_candidate_data(candidate_data.model_dump())
+        db_candidate = Candidate(**data)
+        self.db_session.add(db_candidate)
+        await self.db_session.commit()
+        await self.db_session.refresh(db_candidate)
+        return db_candidate
+
+    async def get_by_id(self, candidate_id: uuid.UUID) -> Optional[Candidate]:
+        stmt = select(Candidate).where(Candidate.id == str(candidate_id))
+        result = await self.db_session.execute(stmt)
+        return result.scalar_one_or_none()
+
+    async def get_by_source_id(self, source: str, source_id: str) -> Optional[Candidate]:
+        stmt = select(Candidate).where(
+            (Candidate.source == source) & (Candidate.source_id == source_id)
+        )
+        result = await self.db_session.execute(stmt)
+        return result.scalar_one_or_none()
+
+    async def get_all(self, skip: int = 0, limit: int = 100, keyword: Optional[str] = None) -> List[Candidate]:
+        stmt = select(Candidate)
+        if keyword:
+            # Search in name, company, title, location, skills
+            stmt = stmt.where(
+                (Candidate.name.contains(keyword)) |
+                (Candidate.company.contains(keyword)) |
+                (Candidate.title.contains(keyword)) |
+                (Candidate.location.contains(keyword))
+            )
+        stmt = stmt.offset(skip).limit(limit)
+        result = await self.db_session.execute(stmt)
+        return result.scalars().all()
+
+    async def update(self, candidate_id: uuid.UUID, candidate_data: CandidateUpdate) -> Optional[Candidate]:
+        db_candidate = await self.get_by_id(candidate_id)
+        if db_candidate:
+            update_data = _serialize_candidate_data(candidate_data.model_dump(exclude_unset=True))
+            for field, value in update_data.items():
+                setattr(db_candidate, field, value)
+            await self.db_session.commit()
+            await self.db_session.refresh(db_candidate)
+        return db_candidate
+
+    async def delete(self, candidate_id: uuid.UUID) -> bool:
+        db_candidate = await self.get_by_id(candidate_id)
+        if db_candidate:
+            await self.db_session.delete(db_candidate)
+            await self.db_session.commit()
+            return True
+        return False
+
+    async def increment_appearance_count(self, source: str, source_id: str) -> Optional[Candidate]:
+        db_candidate = await self.get_by_source_id(source, source_id)
+        if db_candidate:
+            db_candidate.appearance_count += 1
+            # Update source weight based on appearance count
+            if db_candidate.appearance_count <= 2:
+                db_candidate.source_weight = float(db_candidate.appearance_count)
+            else:
+                db_candidate.source_weight = 2.0  # Max weight is 2.0
+            await self.db_session.commit()
+            await self.db_session.refresh(db_candidate)
+        return db_candidate

app/repositories/node_log.py

@@ -0,0 +1,57 @@
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.future import select
+from app.models.node_log import NodeLog
+from app.schemas.node_log import NodeLogCreate, NodeLogUpdate
+from typing import List, Optional
+import uuid
+from datetime import datetime
+
+class NodeLogRepository:
+    def __init__(self, db_session: AsyncSession):
+        self.db_session = db_session
+
+    async def create(self, node_log_data: NodeLogCreate) -> NodeLog:
+        db_node_log = NodeLog(**node_log_data.model_dump())
+        self.db_session.add(db_node_log)
+        await self.db_session.commit()
+        await self.db_session.refresh(db_node_log)
+        return db_node_log
+
+    async def get_by_id(self, node_log_id: uuid.UUID) -> Optional[NodeLog]:
+        stmt = select(NodeLog).where(NodeLog.id == node_log_id)
+        result = await self.db_session.execute(stmt)
+        return result.scalar_one_or_none()
+
+    async def get_by_run(self, run_id: uuid.UUID, skip: int = 0, limit: int = 100) -> List[NodeLog]:
+        stmt = select(NodeLog).where(NodeLog.run_id == run_id).order_by(NodeLog.started_at.desc()).offset(skip).limit(limit)
+        result = await self.db_session.execute(stmt)
+        return result.scalars().all()
+
+    async def get_by_node_name(self, run_id: uuid.UUID, node_name: str) -> List[NodeLog]:
+        stmt = select(NodeLog).where(
+            (NodeLog.run_id == run_id) & (NodeLog.node_name == node_name)
+        )
+        result = await self.db_session.execute(stmt)
+        return result.scalars().all()
+
+    async def get_all(self, skip: int = 0, limit: int = 100) -> List[NodeLog]:
+        stmt = select(NodeLog).offset(skip).limit(limit)
+        result = await self.db_session.execute(stmt)
+        return result.scalars().all()
+
+    async def update(self, node_log_id: uuid.UUID, node_log_data: NodeLogUpdate) -> Optional[NodeLog]:
+        db_node_log = await self.get_by_id(node_log_id)
+        if db_node_log:
+            for field, value in node_log_data.model_dump(exclude_unset=True).items():
+                setattr(db_node_log, field, value)
+            await self.db_session.commit()
+            await self.db_session.refresh(db_node_log)
+        return db_node_log
+
+    async def delete(self, node_log_id: uuid.UUID) -> bool:
+        db_node_log = await self.get_by_id(node_log_id)
+        if db_node_log:
+            await self.db_session.delete(db_node_log)
+            await self.db_session.commit()
+            return True
+        return False

app/repositories/outreach_log.py

@@ -0,0 +1,60 @@
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.future import select
+from app.models.outreach_log import OutreachLog
+from app.schemas.outreach_log import OutreachLogCreate, OutreachLogUpdate
+from typing import List, Optional
+import uuid
+from datetime import datetime
+
+class OutreachLogRepository:
+    def __init__(self, db_session: AsyncSession):
+        self.db_session = db_session
+
+    async def create(self, outreach_log_data: OutreachLogCreate) -> OutreachLog:
+        db_outreach_log = OutreachLog(**outreach_log_data.model_dump())
+        self.db_session.add(db_outreach_log)
+        await self.db_session.commit()
+        await self.db_session.refresh(db_outreach_log)
+        return db_outreach_log
+
+    async def get_by_id(self, outreach_log_id: uuid.UUID) -> Optional[OutreachLog]:
+        stmt = select(OutreachLog).where(OutreachLog.id == outreach_log_id)
+        result = await self.db_session.execute(stmt)
+        return result.scalar_one_or_none()
+
+    async def get_by_pipeline(self, pipeline_id: uuid.UUID, skip: int = 0, limit: int = 100) -> List[OutreachLog]:
+        stmt = select(OutreachLog).where(OutreachLog.pipeline_id == pipeline_id).offset(skip).limit(limit)
+        result = await self.db_session.execute(stmt)
+        return result.scalars().all()
+
+    async def get_all(self, skip: int = 0, limit: int = 100) -> List[OutreachLog]:
+        stmt = select(OutreachLog).offset(skip).limit(limit)
+        result = await self.db_session.execute(stmt)
+        return result.scalars().all()
+
+    async def update_status(self, outreach_log_id: uuid.UUID, status: str) -> Optional[OutreachLog]:
+        db_outreach_log = await self.get_by_id(outreach_log_id)
+        if db_outreach_log:
+            db_outreach_log.status = status
+            db_outreach_log.sent_at = datetime.utcnow()
+            await self.db_session.commit()
+            await self.db_session.refresh(db_outreach_log)
+        return db_outreach_log
+
+    async def update_status_with_error(self, outreach_log_id: uuid.UUID, status: str, error: str) -> Optional[OutreachLog]:
+        db_outreach_log = await self.get_by_id(outreach_log_id)
+        if db_outreach_log:
+            db_outreach_log.status = status
+            db_outreach_log.error = error
+            db_outreach_log.sent_at = datetime.utcnow()
+            await self.db_session.commit()
+            await self.db_session.refresh(db_outreach_log)
+        return db_outreach_log
+
+    async def delete(self, outreach_log_id: uuid.UUID) -> bool:
+        db_outreach_log = await self.get_by_id(outreach_log_id)
+        if db_outreach_log:
+            await self.db_session.delete(db_outreach_log)
+            await self.db_session.commit()
+            return True
+        return False