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

app/services/search.py

@@ -0,0 +1,92 @@
+from typing import List, Dict, Any
+from app.skills.registry import skill_registry
+from app.services.candidate import CandidateService
+from app.repositories.candidate import CandidateRepository
+from app.models.candidate import Candidate
+from app.core.exceptions import GitHubAPIException
+import asyncio
+
+
+class SearchService:
+    """
+    Service for handling candidate searches across different platforms
+    """
+    
+    def __init__(self, candidate_service: CandidateService):
+        self.candidate_service = candidate_service
+        self.skill_registry = skill_registry
+    
+    async def search_candidates(self, position_id: str, keywords: List[str], max_results: int = 100) -> List[Candidate]:
+        """
+        Search for candidates using various skills
+        """
+        all_candidates = []
+        
+        # Use GitHub skill to search for candidates
+        try:
+            github_skill = self.skill_registry.get_skill("github_search")
+            github_results = await github_skill.execute(keywords, max_results)
+            
+            # Convert results to candidate objects
+            for candidate_data in github_results:
+                # Create or update candidate in the database
+                candidate_create_data = {
+                    "source": candidate_data["source"],
+                    "source_id": candidate_data["source_id"],
+                    "github_login": candidate_data["github_login"],
+                    "name": candidate_data["name"],
+                    "email": candidate_data["email"],
+                    "location": candidate_data["location"],
+                    "company": candidate_data["company"],
+                    "title": candidate_data["title"],
+                    "bio": candidate_data["bio"],
+                    "followers": candidate_data["followers"],
+                    "public_repos": candidate_data["public_repos"],
+                    "profile_url": candidate_data["profile_url"],
+                    "avatar_url": candidate_data["avatar_url"],
+                    "skills": candidate_data["skills"],
+                    "search_keywords": candidate_data["search_keywords"]
+                }
+                
+                # Create candidate (this will handle deduplication)
+                candidate = await self.candidate_service.create_candidate(candidate_create_data)
+                all_candidates.append(candidate)
+                
+        except GitHubAPIException as e:
+            # Log the error but continue with other skills if available
+            print(f"GitHub search failed: {str(e)}")
+        except Exception as e:
+            print(f"Unexpected error during search: {str(e)}")
+        
+        return all_candidates
+    
+    async def generate_search_keywords(self, position_title: str, required_skills: List[str], search_keywords: List[str]) -> List[str]:
+        """
+        Generate comprehensive search keywords based on position requirements
+        """
+        keywords = []
+        
+        # Add position title keywords
+        if position_title:
+            keywords.extend([position_title.lower(), position_title.replace(" ", "+")])
+        
+        # Add required skills
+        if required_skills:
+            keywords.extend(required_skills)
+            # Combine skills for more specific searches
+            for i in range(len(required_skills)):
+                for j in range(i+1, len(required_skills)):
+                    combined = f"{required_skills[i]}+{required_skills[j]}"
+                    keywords.append(combined)
+        
+        # Add custom search keywords
+        if search_keywords:
+            keywords.extend(search_keywords)
+        
+        # Remove duplicates while preserving order
+        unique_keywords = []
+        for kw in keywords:
+            if kw not in unique_keywords:
+                unique_keywords.append(kw)
+        
+        return unique_keywords

app/skills/base.py

@@ -0,0 +1,30 @@
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any
+from app.models.candidate import Candidate
+
+
+class BaseSkill(ABC):
+    """
+    Base class for all skills in the Recruiting Loop Agent
+    """
+
+    @abstractmethod
+    async def execute(self, *args, **kwargs) -> List[Dict[str, Any]]:
+        """
+        Execute the skill and return a list of candidate data
+        """
+        pass
+
+    @abstractmethod
+    def name(self) -> str:
+        """
+        Return the name of the skill
+        """
+        pass
+
+    @abstractmethod
+    def description(self) -> str:
+        """
+        Return the description of the skill
+        """
+        pass

app/skills/github.py

@@ -0,0 +1,106 @@
+import httpx
+from typing import List, Dict, Any
+from app.skills.base import BaseSkill
+from app.core.config import settings
+from app.core.exceptions import GitHubAPIException
+import asyncio
+
+class GitHubSkill(BaseSkill):
+    """
+    GitHub search skill for the Recruiting Loop Agent
+    """
+    
+    def __init__(self):
+        self.github_token = settings.github_token
+        self.headers = {
+            "Accept": "application/vnd.github.v3+json",
+            "User-Agent": "Recruiting-Loop-Agent"
+        }
+        if self.github_token:
+            self.headers["Authorization"] = f"token {self.github_token}"
+    
+    async def execute(self, keywords: List[str], max_results: int = 100) -> List[Dict[str, Any]]:
+        """
+        Execute GitHub search and return a list of candidate data
+        """
+        all_candidates = []
+        
+        for keyword in keywords:
+            try:
+                # Search users based on keyword
+                search_url = f"https://api.github.com/search/users?q={keyword}&per_page=30"
+                
+                async with httpx.AsyncClient() as client:
+                    response = await client.get(search_url, headers=self.headers)
+                    
+                    if response.status_code == 200:
+                        data = response.json()
+                        users = data.get("items", [])
+                        
+                        # Get detailed user information for each user
+                        for user in users[:min(len(users), max_results//len(keywords))]:
+                            user_details = await self._get_user_details(user["login"])
+                            if user_details:
+                                all_candidates.append(user_details)
+                                
+                        # Respect rate limits
+                        await asyncio.sleep(1)
+                    elif response.status_code == 403:
+                        # Handle rate limiting
+                        reset_time = int(response.headers.get("X-RateLimit-Reset", 0))
+                        current_time = int(asyncio.get_event_loop().time())
+                        sleep_time = max(reset_time - current_time, 60)
+                        await asyncio.sleep(sleep_time)
+                        continue
+                    else:
+                        raise GitHubAPIException(f"GitHub API returned status code {response.status_code}")
+                        
+            except Exception as e:
+                raise GitHubAPIException(f"Error searching GitHub for keyword '{keyword}': {str(e)}")
+        
+        return all_candidates
+    
+    async def _get_user_details(self, username: str) -> Dict[str, Any]:
+        """
+        Get detailed information about a GitHub user
+        """
+        try:
+            user_url = f"https://api.github.com/users/{username}"
+            
+            async with httpx.AsyncClient() as client:
+                response = await client.get(user_url, headers=self.headers)
+                
+                if response.status_code == 200:
+                    user_data = response.json()
+                    
+                    # Format the user data to match our candidate model
+                    candidate_data = {
+                        "source": "github",
+                        "source_id": str(user_data.get("id", "")),
+                        "github_login": user_data.get("login", ""),
+                        "name": user_data.get("name", ""),
+                        "email": user_data.get("email", ""),
+                        "location": user_data.get("location", ""),
+                        "company": user_data.get("company", ""),
+                        "bio": user_data.get("bio", ""),
+                        "followers": user_data.get("followers", 0),
+                        "public_repos": user_data.get("public_repos", 0),
+                        "profile_url": user_data.get("html_url", ""),
+                        "avatar_url": user_data.get("avatar_url", ""),
+                        "title": "",  # GitHub doesn't have a direct title field
+                        "skills": [],  # Skills would need to be inferred from repos
+                        "search_keywords": []  # Will be populated later
+                    }
+                    
+                    return candidate_data
+                else:
+                    return None
+                    
+        except Exception as e:
+            raise GitHubAPIException(f"Error fetching details for user '{username}': {str(e)}")
+    
+    def name(self) -> str:
+        return "github_search"
+    
+    def description(self) -> str:
+        return "Searches GitHub for potential candidates based on keywords"

app/skills/registry.py

@@ -0,0 +1,51 @@
+from typing import Dict, Type, List
+from app.skills.base import BaseSkill
+from app.skills.github import GitHubSkill
+
+
+class SkillRegistry:
+    """
+    Registry for all available skills in the Recruiting Loop Agent
+    """
+    
+    def __init__(self):
+        self._skills: Dict[str, BaseSkill] = {}
+        self._skill_classes: Dict[str, Type[BaseSkill]] = {
+            "github_search": GitHubSkill
+        }
+        
+    def register_skill(self, skill_name: str, skill_instance: BaseSkill):
+        """
+        Register a new skill instance
+        """
+        self._skills[skill_name] = skill_instance
+        
+    def get_skill(self, skill_name: str) -> BaseSkill:
+        """
+        Get a skill instance by name
+        """
+        if skill_name not in self._skills:
+            if skill_name in self._skill_classes:
+                # Create and register the skill if it's not already registered
+                skill_instance = self._skill_classes[skill_name]()
+                self.register_skill(skill_name, skill_instance)
+            else:
+                raise ValueError(f"Skill '{skill_name}' not found in registry")
+                
+        return self._skills[skill_name]
+        
+    def get_all_skills(self) -> List[BaseSkill]:
+        """
+        Get all available skills
+        """
+        return list(self._skills.values())
+        
+    def get_available_skill_names(self) -> List[str]:
+        """
+        Get names of all available skills
+        """
+        return list(self._skill_classes.keys())
+
+
+# Global skill registry instance
+skill_registry = SkillRegistry()

app/tests/__init__.py

@@ -0,0 +1,3 @@
+"""
+Recruit Loop Agent API Tests
+"""

app/tests/conftest.py

@@ -0,0 +1,96 @@
+"""
+Test configuration and fixtures
+"""
+import pytest
+import pytest_asyncio
+from httpx import AsyncClient, ASGITransport
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+from sqlalchemy.orm import sessionmaker
+from app.database.base import Base
+from app.database.session import get_db
+from app.main import app
+
+# Use in-memory SQLite for tests
+TEST_DATABASE_URL = "sqlite+aiosqlite:///:memory:"
+
+engine = create_async_engine(TEST_DATABASE_URL, echo=False)
+AsyncSessionLocal = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
+
+
+@pytest_asyncio.fixture
+async def db_session():
+    """Create a fresh database session for each test"""
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+    
+    async with AsyncSessionLocal() as session:
+        yield session
+    
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.drop_all)
+
+
+@pytest_asyncio.fixture
+async def client(db_session):
+    """Create a test client with overridden database dependency"""
+    async def override_get_db():
+        yield db_session
+    
+    app.dependency_overrides[get_db] = override_get_db
+    
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as ac:
+        yield ac
+    
+    app.dependency_overrides.clear()
+
+
+@pytest.fixture
+def sample_position_data():
+    """Sample position data for testing"""
+    return {
+        "title": "Senior Software Engineer",
+        "company": "Tech Corp",
+        "description": "Looking for an experienced backend developer",
+        "location": "San Francisco, CA",
+        "required_skills": ["Python", "FastAPI", "PostgreSQL"],
+        "search_keywords": ["backend", "python", "developer"],
+        "loop_interval": 60
+    }
+
+
+@pytest.fixture
+def sample_candidate_data():
+    """Sample candidate data for testing"""
+    return {
+        "source": "github",
+        "source_id": "12345",
+        "github_login": "johndoe",
+        "name": "John Doe",
+        "email": "john@example.com",
+        "location": "San Francisco, CA",
+        "company": "Current Corp",
+        "title": "Software Engineer",
+        "bio": "Experienced Python developer",
+        "followers": 100,
+        "public_repos": 25,
+        "skills": ["Python", "Django", "PostgreSQL"],
+        "profile_url": "https://github.com/johndoe",
+        "avatar_url": "https://github.com/johndoe.png",
+        "search_keywords": ["python", "backend"]
+    }
+
+
+@pytest.fixture
+def sample_pipeline_data():
+    """Sample pipeline data for testing"""
+    import uuid
+    return {
+        "position_id": str(uuid.uuid4()),
+        "candidate_id": str(uuid.uuid4()),
+        "status": "discovered",
+        "score": 85.5,
+        "contact_count": 0,
+        "candidate_interest": "high",
+        "notes": "Strong candidate"
+    }

app/tests/generate_report.py

@@ -0,0 +1,144 @@
+"""
+Test report generator
+Generates a Markdown report from pytest results
+"""
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+
+
+def run_tests_and_generate_report():
+    """Run pytest and generate a Markdown test report"""
+    
+    # Run pytest with verbose output
+    project_root = Path(__file__).parent.parent.parent
+    result = subprocess.run(
+        ["pytest", "app/tests/", "-v", "--tb=short"],
+        capture_output=True,
+        text=True,
+        cwd=str(project_root)
+    )
+    
+    # Parse test results
+    test_results = []
+    
+    for line in result.stdout.split('\n'):
+        line = line.strip()
+        if '::test_' in line and ('PASSED' in line or 'FAILED' in line or 'SKIPPED' in line):
+            # Parse test line like: app/tests/test_positions.py::test_create_position PASSED [ 59%]
+            parts = line.split('::')
+            if len(parts) >= 2:
+                file_part = parts[0]
+                module = file_part.replace('app/tests/test_', '').replace('.py', '')
+                
+                # The last part contains test name and status
+                last_part = parts[-1]
+                test_name = last_part.split(' ')[0]
+                
+                if 'PASSED' in line:
+                    status = 'PASSED'
+                elif 'FAILED' in line:
+                    status = 'FAILED'
+                else:
+                    status = 'SKIPPED'
+                
+                test_results.append({
+                    'module': module,
+                    'test_name': test_name,
+                    'status': status,
+                    'line': line
+                })
+    
+    # Generate Markdown report
+    report = []
+    report.append("# Recruit Loop Agent API 测试报告")
+    report.append("")
+    report.append(f"**生成时间**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    report.append("")
+    
+    # Test environment
+    report.append("## 测试环境说明")
+    report.append("")
+    report.append("- **测试框架**: pytest + pytest-asyncio")
+    report.append("- **HTTP 客户端**: httpx.AsyncClient")
+    report.append("- **数据库**: SQLite (内存模式)")
+    report.append("- **测试目标**: FastAPI 应用所有 API 接口")
+    report.append("")
+    
+    # Summary
+    total = len(test_results)
+    passed = sum(1 for t in test_results if t['status'] == 'PASSED')
+    failed = sum(1 for t in test_results if t['status'] == 'FAILED')
+    skipped = sum(1 for t in test_results if t['status'] == 'SKIPPED')
+    
+    report.append("## 测试执行摘要")
+    report.append("")
+    report.append(f"- **总测试用例数**: {total}")
+    report.append(f"- **通过**: {passed}")
+    report.append(f"- **失败**: {failed}")
+    report.append(f"- **跳过**: {skipped}")
+    report.append(f"- **通过率**: {(passed/total*100) if total > 0 else 0:.2f}%")
+    report.append("")
+    
+    # Module breakdown
+    report.append("## 各模块测试详情")
+    report.append("")
+    
+    modules = {}
+    for test in test_results:
+        module = test['module']
+        if module not in modules:
+            modules[module] = []
+        modules[module].append(test)
+    
+    for module, tests in sorted(modules.items()):
+        report.append(f"### {module.upper()} 模块")
+        report.append("")
+        report.append("| 测试用例 | 状态 |")
+        report.append("|---------|------|")
+        
+        for test in tests:
+            status_icon = "✅" if test['status'] == 'PASSED' else "❌" if test['status'] == 'FAILED' else "⏭️"
+            report.append(f"| {test['test_name']} | {status_icon} {test['status']} |")
+        
+        report.append("")
+    
+    # Failed tests details
+    if failed > 0:
+        report.append("## 失败用例详情")
+        report.append("")
+        
+        for test in test_results:
+            if test['status'] == 'FAILED':
+                report.append(f"### {test['module']}::{test['test_name']}")
+                report.append("")
+                report.append("```")
+                # Extract error from pytest output
+                report.append(test['line'])
+                report.append("```")
+                report.append("")
+    
+    # Full output
+    report.append("## 完整测试输出")
+    report.append("")
+    report.append("```")
+    report.append(result.stdout)
+    report.append("```")
+    report.append("")
+    
+    # Write report to file
+    project_root = Path(__file__).parent.parent.parent
+    report_path = project_root / "docs" / "api_test_report.md"
+    report_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    with open(report_path, 'w', encoding='utf-8') as f:
+        f.write('\n'.join(report))
+    
+    print(f"测试报告已生成: {report_path}")
+    
+    return result.returncode
+
+
+if __name__ == "__main__":
+    sys.exit(run_tests_and_generate_report())

app/tests/test_candidates.py

@@ -0,0 +1,158 @@
+"""
+Candidates API tests
+"""
+import pytest
+import uuid
+
+
+@pytest.mark.asyncio
+async def test_create_candidate(client, sample_candidate_data):
+    """Test creating a new candidate"""
+    response = await client.post("/api/v1/candidates", json=sample_candidate_data)
+    
+    assert response.status_code == 200
+    data = response.json()
+    
+    assert data["source"] == sample_candidate_data["source"]
+    assert data["source_id"] == sample_candidate_data["source_id"]
+    assert data["github_login"] == sample_candidate_data["github_login"]
+    assert data["name"] == sample_candidate_data["name"]
+    assert "id" in data
+    assert "created_at" in data
+    assert "updated_at" in data
+    assert data["appearance_count"] == 1
+    assert data["source_weight"] == 1.0
+
+
+@pytest.mark.asyncio
+async def test_create_duplicate_candidate(client, sample_candidate_data):
+    """Test creating a duplicate candidate increments appearance count"""
+    # Create first time
+    response1 = await client.post("/api/v1/candidates", json=sample_candidate_data)
+    assert response1.status_code == 200
+    
+    # Create duplicate
+    response2 = await client.post("/api/v1/candidates", json=sample_candidate_data)
+    assert response2.status_code == 200
+    
+    data = response2.json()
+    assert data["appearance_count"] == 2
+    assert data["source_weight"] == 2.0
+
+
+@pytest.mark.asyncio
+async def test_get_candidates(client, sample_candidate_data):
+    """Test getting all candidates"""
+    await client.post("/api/v1/candidates", json=sample_candidate_data)
+    
+    response = await client.get("/api/v1/candidates")
+    
+    assert response.status_code == 200
+    data = response.json()
+    
+    assert isinstance(data, list)
+    assert len(data) >= 1
+
+
+@pytest.mark.asyncio
+async def test_get_candidates_with_pagination(client, sample_candidate_data):
+    """Test getting candidates with pagination"""
+    # Create multiple candidates
+    for i in range(3):
+        data = sample_candidate_data.copy()
+        data["source_id"] = str(10000 + i)
+        data["github_login"] = f"user{i}"
+        await client.post("/api/v1/candidates", json=data)
+    
+    response = await client.get("/api/v1/candidates?skip=0&limit=2")
+    
+    assert response.status_code == 200
+    data = response.json()
+    assert len(data) == 2
+
+
+@pytest.mark.asyncio
+async def test_get_candidates_with_keyword_filter(client, sample_candidate_data):
+    """Test getting candidates with keyword filter"""
+    await client.post("/api/v1/candidates", json=sample_candidate_data)
+    
+    response = await client.get("/api/v1/candidates?keyword=John")
+    
+    assert response.status_code == 200
+    data = response.json()
+    assert len(data) >= 1
+    assert any("John" in c.get("name", "") for c in data)
+
+
+@pytest.mark.asyncio
+async def test_get_candidate_by_id(client, sample_candidate_data):
+    """Test getting a specific candidate by ID"""
+    create_response = await client.post("/api/v1/candidates", json=sample_candidate_data)
+    candidate_id = create_response.json()["id"]
+    
+    response = await client.get(f"/api/v1/candidates/{candidate_id}")
+    
+    assert response.status_code == 200
+    data = response.json()
+    assert data["id"] == candidate_id
+    assert data["name"] == sample_candidate_data["name"]
+
+
+@pytest.mark.asyncio
+async def test_get_candidate_not_found(client):
+    """Test getting a non-existent candidate"""
+    fake_id = str(uuid.uuid4())
+    response = await client.get(f"/api/v1/candidates/{fake_id}")
+    
+    assert response.status_code == 404
+
+
+@pytest.mark.asyncio
+async def test_update_candidate(client, sample_candidate_data):
+    """Test updating a candidate"""
+    create_response = await client.post("/api/v1/candidates", json=sample_candidate_data)
+    candidate_id = create_response.json()["id"]
+    
+    update_data = {"name": "Jane Doe", "title": "Senior Developer"}
+    response = await client.put(f"/api/v1/candidates/{candidate_id}", json=update_data)
+    
+    assert response.status_code == 200
+    data = response.json()
+    assert data["name"] == "Jane Doe"
+    assert data["title"] == "Senior Developer"
+
+
+@pytest.mark.asyncio
+async def test_update_candidate_not_found(client):
+    """Test updating a non-existent candidate"""
+    fake_id = str(uuid.uuid4())
+    update_data = {"name": "Updated Name"}
+    response = await client.put(f"/api/v1/candidates/{fake_id}", json=update_data)
+    
+    assert response.status_code == 404
+
+
+@pytest.mark.asyncio
+async def test_delete_candidate(client, sample_candidate_data):
+    """Test deleting a candidate"""
+    create_response = await client.post("/api/v1/candidates", json=sample_candidate_data)
+    candidate_id = create_response.json()["id"]
+    
+    response = await client.delete(f"/api/v1/candidates/{candidate_id}")
+    
+    assert response.status_code == 200
+    data = response.json()
+    assert data["message"] == "Candidate deleted successfully"
+    
+    # Verify it's deleted
+    get_response = await client.get(f"/api/v1/candidates/{candidate_id}")
+    assert get_response.status_code == 404
+
+
+@pytest.mark.asyncio
+async def test_delete_candidate_not_found(client):
+    """Test deleting a non-existent candidate"""
+    fake_id = str(uuid.uuid4())
+    response = await client.delete(f"/api/v1/candidates/{fake_id}")
+    
+    assert response.status_code == 404