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

app/repositories/pipeline.py

@@ -0,0 +1,80 @@
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.future import select
+from app.models.pipeline import Pipeline
+from app.schemas.pipeline import PipelineCreate, PipelineUpdate
+from typing import List, Optional
+import uuid
+
+def _serialize_pipeline_data(data: dict) -> dict:
+    """Convert UUID fields to strings for database storage."""
+    for field in ("position_id", "candidate_id"):
+        if field in data and data[field] is not None:
+            data[field] = str(data[field])
+    return data
+
+
+class PipelineRepository:
+    def __init__(self, db_session: AsyncSession):
+        self.db_session = db_session
+
+    async def create(self, pipeline_data: PipelineCreate) -> Pipeline:
+        data = _serialize_pipeline_data(pipeline_data.model_dump())
+        db_pipeline = Pipeline(**data)
+        self.db_session.add(db_pipeline)
+        await self.db_session.commit()
+        await self.db_session.refresh(db_pipeline)
+        return db_pipeline
+
+    async def get_by_id(self, pipeline_id: uuid.UUID) -> Optional[Pipeline]:
+        stmt = select(Pipeline).where(Pipeline.id == str(pipeline_id))
+        result = await self.db_session.execute(stmt)
+        return result.scalar_one_or_none()
+
+    async def get_by_position_and_candidate(self, position_id: uuid.UUID, candidate_id: uuid.UUID) -> Optional[Pipeline]:
+        stmt = select(Pipeline).where(
+            (Pipeline.position_id == str(position_id)) & (Pipeline.candidate_id == str(candidate_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[Pipeline]:
+        stmt = select(Pipeline).where(Pipeline.position_id == str(position_id)).offset(skip).limit(limit)
+        result = await self.db_session.execute(stmt)
+        return result.scalars().all()
+
+    async def get_by_status(self, position_id: uuid.UUID, status: str) -> List[Pipeline]:
+        stmt = select(Pipeline).where(
+            (Pipeline.position_id == str(position_id)) & (Pipeline.status == status)
+        )
+        result = await self.db_session.execute(stmt)
+        return result.scalars().all()
+
+    async def get_all(self, skip: int = 0, limit: int = 100) -> List[Pipeline]:
+        stmt = select(Pipeline).offset(skip).limit(limit)
+        result = await self.db_session.execute(stmt)
+        return result.scalars().all()
+
+    async def update(self, pipeline_id: uuid.UUID, pipeline_data: PipelineUpdate) -> Optional[Pipeline]:
+        db_pipeline = await self.get_by_id(pipeline_id)
+        if db_pipeline:
+            for field, value in pipeline_data.model_dump(exclude_unset=True).items():
+                setattr(db_pipeline, field, value)
+            await self.db_session.commit()
+            await self.db_session.refresh(db_pipeline)
+        return db_pipeline
+
+    async def update_status(self, pipeline_id: uuid.UUID, status: str) -> Optional[Pipeline]:
+        db_pipeline = await self.get_by_id(pipeline_id)
+        if db_pipeline:
+            db_pipeline.status = status
+            await self.db_session.commit()
+            await self.db_session.refresh(db_pipeline)
+        return db_pipeline
+
+    async def delete(self, pipeline_id: uuid.UUID) -> bool:
+        db_pipeline = await self.get_by_id(pipeline_id)
+        if db_pipeline:
+            await self.db_session.delete(db_pipeline)
+            await self.db_session.commit()
+            return True
+        return False

app/repositories/position.py

@@ -0,0 +1,67 @@
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.future import select
+from app.models.position import Position
+from app.schemas.position import PositionCreate, PositionUpdate
+from typing import List, Optional
+import json
+import uuid
+
+
+def _serialize_position_data(data: dict) -> dict:
+    """Serialize list fields to JSON strings for database storage."""
+    for field in ("required_skills", "search_keywords"):
+        if field in data and data[field] is not None:
+            data[field] = json.dumps(data[field])
+    return data
+
+class PositionRepository:
+    def __init__(self, db_session: AsyncSession):
+        self.db_session = db_session
+
+    async def create(self, position_data: PositionCreate) -> Position:
+        data = _serialize_position_data(position_data.model_dump())
+        db_position = Position(**data)
+        self.db_session.add(db_position)
+        await self.db_session.commit()
+        await self.db_session.refresh(db_position)
+        return db_position
+
+    async def get_by_id(self, position_id: uuid.UUID) -> Optional[Position]:
+        stmt = select(Position).where(Position.id == str(position_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, status: Optional[str] = None) -> List[Position]:
+        stmt = select(Position)
+        if status:
+            stmt = stmt.where(Position.status == status)
+        stmt = stmt.offset(skip).limit(limit)
+        result = await self.db_session.execute(stmt)
+        return result.scalars().all()
+
+    async def update(self, position_id: uuid.UUID, position_data: PositionUpdate) -> Optional[Position]:
+        db_position = await self.get_by_id(position_id)
+        if db_position:
+            update_data = _serialize_position_data(position_data.model_dump(exclude_unset=True))
+            for field, value in update_data.items():
+                setattr(db_position, field, value)
+            await self.db_session.commit()
+            await self.db_session.refresh(db_position)
+        return db_position
+
+    async def delete(self, position_id: uuid.UUID) -> bool:
+        db_position = await self.get_by_id(position_id)
+        if db_position:
+            await self.db_session.delete(db_position)
+            await self.db_session.commit()
+            return True
+        return False
+
+    async def update_status(self, position_id: uuid.UUID, status: str) -> Optional[Position]:
+        db_position = await self.get_by_id(position_id)
+        if db_position:
+            db_position.status = status
+            db_position.loop_enabled = (status == "active")
+            await self.db_session.commit()
+            await self.db_session.refresh(db_position)
+        return db_position

app/repositories/scheduler_job.py

@@ -0,0 +1,74 @@
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.future import select
+from app.models.scheduler_job import SchedulerJob
+from app.schemas.scheduler_job import SchedulerJobCreate, SchedulerJobUpdate
+from typing import List, Optional
+import uuid
+from datetime import datetime
+
+class SchedulerJobRepository:
+    def __init__(self, db_session: AsyncSession):
+        self.db_session = db_session
+
+    async def create(self, job_data: dict) -> SchedulerJob:
+        db_job = SchedulerJob(**job_data)
+        self.db_session.add(db_job)
+        await self.db_session.commit()
+        await self.db_session.refresh(db_job)
+        return db_job
+
+    async def get_by_id(self, job_id: uuid.UUID) -> Optional[SchedulerJob]:
+        stmt = select(SchedulerJob).where(SchedulerJob.id == job_id)
+        result = await self.db_session.execute(stmt)
+        return result.scalar_one_or_none()
+
+    async def get_by_position_id(self, position_id: uuid.UUID) -> Optional[SchedulerJob]:
+        stmt = select(SchedulerJob).where(SchedulerJob.position_id == position_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) -> List[SchedulerJob]:
+        stmt = select(SchedulerJob).offset(skip).limit(limit)
+        result = await self.db_session.execute(stmt)
+        return result.scalars().all()
+
+    async def update(self, job_id: uuid.UUID, job_data: dict) -> Optional[SchedulerJob]:
+        db_job = await self.get_by_id(job_id)
+        if db_job:
+            for field, value in job_data.items():
+                setattr(db_job, field, value)
+            await self.db_session.commit()
+            await self.db_session.refresh(db_job)
+        return db_job
+
+    async def update_status(self, position_id: uuid.UUID, status: str) -> Optional[SchedulerJob]:
+        db_job = await self.get_by_position_id(position_id)
+        if db_job:
+            db_job.status = status
+            await self.db_session.commit()
+            await self.db_session.refresh(db_job)
+        return db_job
+
+    async def update_last_run(self, position_id: uuid.UUID, last_run: datetime) -> Optional[SchedulerJob]:
+        db_job = await self.get_by_position_id(position_id)
+        if db_job:
+            db_job.last_run = last_run
+            await self.db_session.commit()
+            await self.db_session.refresh(db_job)
+        return db_job
+
+    async def increment_run_count(self, position_id: uuid.UUID) -> Optional[SchedulerJob]:
+        db_job = await self.get_by_position_id(position_id)
+        if db_job:
+            db_job.total_runs += 1
+            await self.db_session.commit()
+            await self.db_session.refresh(db_job)
+        return db_job
+
+    async def delete(self, job_id: uuid.UUID) -> bool:
+        db_job = await self.get_by_id(job_id)
+        if db_job:
+            await self.db_session.delete(db_job)
+            await self.db_session.commit()
+            return True
+        return False

app/schemas/agent_run.py

@@ -0,0 +1,32 @@
+from pydantic import BaseModel
+from typing import Optional
+from datetime import datetime
+import uuid
+
+class AgentRunBase(BaseModel):
+    position_id: uuid.UUID
+    candidates_found: Optional[int] = 0
+    candidates_added: Optional[int] = 0
+    emails_sent: Optional[int] = 0
+    status: Optional[str] = "running"  # running, success, failed
+    error: Optional[str] = None
+
+class AgentRunCreate(AgentRunBase):
+    position_id: uuid.UUID
+    started_at: datetime
+
+class AgentRunUpdate(BaseModel):
+    candidates_found: Optional[int] = None
+    candidates_added: Optional[int] = None
+    emails_sent: Optional[int] = None
+    status: Optional[str] = None
+    error: Optional[str] = None
+
+class AgentRun(AgentRunBase):
+    id: uuid.UUID
+    started_at: datetime
+    finished_at: Optional[datetime] = None
+    duration_ms: Optional[int] = None
+
+    class Config:
+        from_attributes = True

app/schemas/candidate.py

@@ -0,0 +1,58 @@
+from pydantic import BaseModel, field_validator
+from typing import Optional, List
+from datetime import datetime
+import json
+import uuid
+
+class CandidateBase(BaseModel):
+    source: str
+    source_id: str
+    github_login: Optional[str] = None
+    name: Optional[str] = None
+    email: Optional[str] = None
+    location: Optional[str] = None
+    company: Optional[str] = None
+    title: Optional[str] = None
+    bio: Optional[str] = None
+    followers: Optional[int] = 0
+    public_repos: Optional[int] = 0
+    skills: Optional[List[str]] = None
+    profile_url: Optional[str] = None
+    avatar_url: Optional[str] = None
+    search_keywords: Optional[List[str]] = None
+
+class CandidateCreate(CandidateBase):
+    pass
+
+class CandidateUpdate(BaseModel):
+    name: Optional[str] = None
+    email: Optional[str] = None
+    location: Optional[str] = None
+    company: Optional[str] = None
+    title: Optional[str] = None
+    bio: Optional[str] = None
+    followers: Optional[int] = None
+    public_repos: Optional[int] = None
+    skills: Optional[List[str]] = None
+    profile_url: Optional[str] = None
+    avatar_url: Optional[str] = None
+
+class Candidate(CandidateBase):
+    id: uuid.UUID
+    appearance_count: int = 1
+    source_weight: float = 1.0
+    created_at: datetime
+    updated_at: datetime
+
+    @field_validator('skills', 'search_keywords', mode='before')
+    @classmethod
+    def deserialize_json_fields(cls, v):
+        if isinstance(v, str):
+            try:
+                return json.loads(v)
+            except (json.JSONDecodeError, TypeError):
+                return v
+        return v
+
+    class Config:
+        from_attributes = True

app/schemas/node_log.py

@@ -0,0 +1,31 @@
+from pydantic import BaseModel
+from typing import Optional
+from datetime import datetime
+import uuid
+
+class NodeLogBase(BaseModel):
+    run_id: uuid.UUID
+    node_name: str  # search, dedup, score, outreach, evaluate
+    status: Optional[str] = None  # success, failed
+    input: Optional[str] = None  # JSON string of input data
+    output: Optional[str] = None  # JSON string of output data
+    error: Optional[str] = None
+
+class NodeLogCreate(NodeLogBase):
+    run_id: uuid.UUID
+    node_name: str
+
+class NodeLogUpdate(BaseModel):
+    status: Optional[str] = None
+    input: Optional[str] = None
+    output: Optional[str] = None
+    error: Optional[str] = None
+
+class NodeLog(NodeLogBase):
+    id: uuid.UUID
+    started_at: datetime
+    finished_at: Optional[datetime] = None
+    duration_ms: Optional[int] = None
+
+    class Config:
+        from_attributes = True

app/schemas/outreach_log.py

@@ -0,0 +1,28 @@
+from pydantic import BaseModel
+from typing import Optional
+from datetime import datetime
+import uuid
+
+class OutreachLogBase(BaseModel):
+    pipeline_id: uuid.UUID
+    subject: Optional[str] = None
+    body: Optional[str] = None
+    status: Optional[str] = "pending"  # pending, sent, failed
+    error: Optional[str] = None
+
+class OutreachLogCreate(OutreachLogBase):
+    pipeline_id: uuid.UUID
+    subject: str
+    body: str
+
+class OutreachLogUpdate(BaseModel):
+    status: Optional[str] = None
+    error: Optional[str] = None
+
+class OutreachLog(OutreachLogBase):
+    id: uuid.UUID
+    sent_at: Optional[datetime] = None
+    created_at: datetime
+
+    class Config:
+        from_attributes = True

app/schemas/pipeline.py

@@ -0,0 +1,34 @@
+from pydantic import BaseModel
+from typing import Optional
+from datetime import datetime
+import uuid
+
+class PipelineBase(BaseModel):
+    position_id: uuid.UUID
+    candidate_id: uuid.UUID
+    status: Optional[str] = "discovered"
+    score: Optional[float] = 0.0
+    contact_count: Optional[int] = 0
+    candidate_interest: Optional[str] = None
+    notes: Optional[str] = None
+
+class PipelineCreate(PipelineBase):
+    pass
+
+class PipelineUpdate(BaseModel):
+    status: Optional[str] = None
+    score: Optional[float] = None
+    contact_count: Optional[int] = None
+    candidate_interest: Optional[str] = None
+    notes: Optional[str] = None
+
+class Pipeline(PipelineBase):
+    id: uuid.UUID
+    score_detail: Optional[str] = None
+    last_contacted_at: Optional[datetime] = None
+    next_followup_at: Optional[datetime] = None
+    created_at: datetime
+    updated_at: datetime
+
+    class Config:
+        from_attributes = True

app/schemas/position.py

@@ -0,0 +1,49 @@
+from pydantic import BaseModel, field_validator
+from typing import Optional, List, Union
+from datetime import datetime
+import json
+import uuid
+
+class PositionBase(BaseModel):
+    title: str
+    company: str
+    description: Optional[str] = None
+    location: Optional[str] = None
+    required_skills: Optional[List[str]] = None
+    search_keywords: Optional[List[str]] = None
+    loop_interval: Optional[int] = 60
+
+class PositionCreate(PositionBase):
+    pass
+
+class PositionUpdate(BaseModel):
+    title: Optional[str] = None
+    company: Optional[str] = None
+    description: Optional[str] = None
+    location: Optional[str] = None
+    required_skills: Optional[List[str]] = None
+    search_keywords: Optional[List[str]] = None
+    loop_interval: Optional[int] = None
+    status: Optional[str] = None
+
+class Position(PositionBase):
+    id: uuid.UUID
+    status: str = "active"
+    loop_enabled: bool = True
+    last_loop_at: Optional[datetime] = None
+    next_loop_at: Optional[datetime] = None
+    created_at: datetime
+    updated_at: datetime
+
+    @field_validator('required_skills', 'search_keywords', mode='before')
+    @classmethod
+    def deserialize_json_fields(cls, v):
+        if isinstance(v, str):
+            try:
+                return json.loads(v)
+            except (json.JSONDecodeError, TypeError):
+                return v
+        return v
+
+    class Config:
+        from_attributes = True

app/schemas/scheduler_job.py

@@ -0,0 +1,29 @@
+from pydantic import BaseModel
+from typing import Optional
+from datetime import datetime
+import uuid
+
+class SchedulerJobBase(BaseModel):
+    position_id: uuid.UUID
+    enabled: Optional[bool] = True
+    interval_minutes: Optional[int] = 60
+    status: Optional[str] = "waiting"  # waiting, running, paused, error
+
+class SchedulerJobCreate(SchedulerJobBase):
+    position_id: uuid.UUID
+
+class SchedulerJobUpdate(BaseModel):
+    enabled: Optional[bool] = None
+    interval_minutes: Optional[int] = None
+    status: Optional[str] = None
+
+class SchedulerJob(SchedulerJobBase):
+    id: uuid.UUID
+    next_run: Optional[datetime] = None
+    last_run: Optional[datetime] = None
+    total_runs: int = 0
+    created_at: datetime
+    updated_at: datetime
+
+    class Config:
+        from_attributes = True

app/services/candidate.py

@@ -0,0 +1,58 @@
+from typing import List, Optional
+from app.repositories.candidate import CandidateRepository
+from app.schemas.candidate import CandidateCreate, CandidateUpdate, Candidate
+from app.core.exceptions import CandidateNotFoundException
+import uuid
+
+class CandidateService:
+    def __init__(self, candidate_repo: CandidateRepository):
+        self.candidate_repo = candidate_repo
+
+    async def create_candidate(self, candidate_data: CandidateCreate) -> Candidate:
+        # Check if candidate already exists by source and source_id
+        existing_candidate = await self.candidate_repo.get_by_source_id(
+            candidate_data.source, 
+            candidate_data.source_id
+        )
+        
+        if existing_candidate:
+            # Increment appearance count and return existing candidate
+            return await self.candidate_repo.increment_appearance_count(
+                candidate_data.source, 
+                candidate_data.source_id
+            )
+        else:
+            # Create new candidate
+            return await self.candidate_repo.create(candidate_data)
+
+    async def get_candidate_by_id(self, candidate_id: uuid.UUID) -> Candidate:
+        candidate = await self.candidate_repo.get_by_id(candidate_id)
+        if not candidate:
+            raise CandidateNotFoundException(f"Candidate with id {candidate_id} not found")
+        return candidate
+
+    async def get_candidate_by_source_id(self, source: str, source_id: str) -> Optional[Candidate]:
+        return await self.candidate_repo.get_by_source_id(source, source_id)
+
+    async def get_all_candidates(self, skip: int = 0, limit: int = 100, keyword: Optional[str] = None) -> List[Candidate]:
+        return await self.candidate_repo.get_all(skip, limit, keyword)
+
+    async def update_candidate(self, candidate_id: uuid.UUID, candidate_data: CandidateUpdate) -> Optional[Candidate]:
+        return await self.candidate_repo.update(candidate_id, candidate_data)
+
+    async def delete_candidate(self, candidate_id: uuid.UUID) -> bool:
+        return await self.candidate_repo.delete(candidate_id)
+
+    async def deduplicate_candidates(self, source: str, source_ids: List[str]) -> List[Candidate]:
+        """
+        Find existing candidates and return a list of new candidates to be created
+        """
+        new_candidates = []
+        for source_id in source_ids:
+            existing = await self.candidate_repo.get_by_source_id(source, source_id)
+            if not existing:
+                new_candidates.append(source_id)
+            else:
+                # Increment appearance count for existing candidate
+                await self.candidate_repo.increment_appearance_count(source, source_id)
+        return new_candidates