Minimal AI Job Search Agent

#!/bin/bash
mkdir -p uvf_ai_job_search
cd uvf_ai_job_search
pip install requests
python -c "import sqlite3; print('SQLite3 ready')"

import sqlite3

DB_NAME = 'jobs.db'

def init_db():
    conn = sqlite3.connect(DB_NAME)
    cursor = conn.cursor()
    
    # Create table
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS jobs (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            title TEXT NOT NULL,
            company TEXT NOT NULL,
            description TEXT NOT NULL,
            keywords TEXT
        )
    ''')
    
    # Insert sample data if empty
    cursor.execute('SELECT count(*) FROM jobs')
    if cursor.fetchone()[0] == 0:
        sample_jobs = [
            ('Senior Python Developer', 'TechCorp', 'We are looking for an experienced Python developer to join our remote team. Must have 5+ years experience.', 'python,remote,senior'),
            ('Junior Web Developer', 'StartupInc', 'Looking for a junior developer to help build our web platform. Knowledge of JavaScript and React required.', 'javascript,react,junior'),
            ('Data Scientist', 'DataDriven', 'Seeking a data scientist with strong Python and SQL skills to analyze large datasets.', 'python,sql,data')
        ]
        cursor.executemany('INSERT INTO jobs (title, company, description, keywords) VALUES (?, ?, ?, ?)', sample_jobs)
        conn.commit()
        print(f'Inserted {len(sample_jobs)} sample jobs.')
    else:
        print('Database already populated.')
    
    conn.close()

if __name__ == '__main__':
    init_db()
    print('Database initialized successfully.')

import sqlite3

DB_NAME = 'jobs.db'

def filter_jobs(keywords):
    """
    Query the database for jobs matching the provided keywords.
    Keywords is a list of strings.
    """
    conn = sqlite3.connect(DB_NAME)
    cursor = conn.cursor()
    
    # Simple LIKE query for each keyword
    # Note: This is a basic implementation. For production, consider full-text search.
    conditions = " OR ".join(["description LIKE ?" for _ in keywords])
    params = [f'%{kw.lower()}%' for kw in keywords]
    
    query = f"SELECT id, title, company, description FROM jobs WHERE {conditions}"
    
    try:
        cursor.execute(query, params)
        results = cursor.fetchall()
        return results
    except Exception as e:
        print(f"Error querying database: {e}")
        return []
    finally:
        conn.close()

if __name__ == '__main__':
    # Test the filter
    keywords = ['Python']
    jobs = filter_jobs(keywords)
    print(f"Found {len(jobs)} jobs matching '{keywords}':")
    for job in jobs:
        print(f"- {job[1]} at {job[2]}")

import requests
import os
import json

# Use environment variable for API key, or set a default for testing
API_KEY = os.getenv('OPENAI_API_KEY', 'sk-your-api-key-here')
API_URL = 'https://api.openai.com/v1/chat/completions'

def generate_cover_letter(job_title, company, job_description, user_profile):
    """
    Generate a cover letter using the OpenAI API.
    """
    if API_KEY == 'sk-your-api-key-here':
        return "[API Key not set. Set OPENAI_API_KEY environment variable.]"
    
    prompt = f"""
    Write a professional cover letter for the following job application:
    
    Job Title: {job_title}
    Company: {company}
    Job Description: {job_description}
    
    User Profile: {user_profile}
    
    Please keep the tone professional and enthusiastic.
    """
    
    headers = {
        'Content-Type': 'application/json',
        'Authorization': f'Bearer {API_KEY}'
    }
    
    payload = {
        'model': 'gpt-3.5-turbo',
        'messages': [
            {'role': 'system', 'content': 'You are a helpful career assistant.'},
            {'role': 'user', 'content': prompt}
        ],
        'max_tokens': 500
    }
    
    try:
        response = requests.post(API_URL, headers=headers, json=payload)
        response.raise_for_status()
        data = response.json()
        return data['choices'][0]['message']['content']
    except requests.exceptions.RequestException as e:
        print(f"API Error: {e}")
        return None
    except (KeyError, IndexError) as e:
        print(f"Response parsing error: {e}")
        return None

if __name__ == '__main__':
    # Test the AI agent
    test_job = {
        'title': 'Python Developer',
        'company': 'TechCorp',
        'description': 'Looking for a Python expert.'
    }
    user_profile = "I am a passionate Python developer with 3 years of experience."
    
    letter = generate_cover_letter(
        test_job['title'],
        test_job['company'],
        test_job['description'],
        user_profile
    )
    print("Generated Cover Letter:")
    print(letter)

import sqlite3
import json
import os
from job_filter import get_matching_jobs
from ai_agent import generate_cover_letter

def main():
    db_path = "jobs.db"
    if not os.path.exists(db_path):
        print("Error: Database not found. Run db_init.py first.")
        return

    try:
        # 1. Filter jobs
        keywords = ["Python", "Remote"]
        jobs = get_matching_jobs(db_path, keywords)
        
        if not jobs:
            print("No matching jobs found.")
            return

        print(f"Found {len(jobs)} matching job(s).")
        
        # 2. Generate cover letter for the first match
        target_job = jobs[0]
        print(f"\nGenerating cover letter for: {target_job['title']} at {target_job['company']}...")
        
        # Mock user profile (static for this minimal clone)
        user_profile = {
            "name": "Alex Dev",
            "experience": "3 years in Python backend development",
            "skills": ["Python", "SQL", "Docker"]
        }
        
        cover_letter = generate_cover_letter(target_job, user_profile)
        
        # 3. Output result
        print("\n--- Generated Cover Letter ---")
        print(cover_letter)
        print("--- End of Letter ---")

    except Exception as e:
        print(f"An error occurred: {e}")

if __name__ == "__main__":
    main()

python main.py