tools.py

"""
Custom tools for Job Application Assistant Agent
"""

import json
from pathlib import Path
from datetime import datetime
import google.generativeai as genai

from config import config


def llm(prompt: str, temperature: float = None, model: str = None) -> str:
    """
    Call Google Gemini API with the given prompt.
    
    Args:
        prompt (str): The prompt to send to the AI
        temperature (float): Controls randomness (0.0-1.0)
        model (str): Gemini model to use
        
    Returns:
        str: AI-generated response
    """
    if temperature is None:
        temperature = config.temperature
    if model is None:
        model = config.worker_model
        
    try:
        llm_model = genai.GenerativeModel(model)
        response = llm_model.generate_content(
            prompt,
            generation_config=genai.types.GenerationConfig(
                temperature=temperature,
            )
        )
        return response.text
    except Exception as e:
        error_msg = f"[Gemini API Error] {str(e)}"
        print(error_msg)
        raise RuntimeError(error_msg)


def read_text_file(file_path: str) -> dict:
    """
    Reads a text file and returns its content.
    
    Args:
        file_path (str): Path to the text file
        
    Returns:
        dict: Dictionary with status and content
    """
    try:
        path = Path(file_path)
        if not path.exists():
            return {
                "status": "error",
                "error": f"File not found: {file_path}"
            }
        
        content = path.read_text(encoding='utf-8')
        return {
            "status": "success",
            "content": content,
            "file_path": str(path)
        }
    except Exception as e:
        return {
            "status": "error",
            "error": str(e)
        }


def save_json_file(data: dict, output_path: str) -> dict:
    """
    Save data to JSON file.
    
    Args:
        data (dict): Data to save
        output_path (str): Path to save the JSON file
        
    Returns:
        dict: Dictionary with status and file path
    """
    try:
        output = Path(output_path)
        output.parent.mkdir(parents=True, exist_ok=True)
        
        with open(output, 'w', encoding='utf-8') as f:
            json.dump(data, f, indent=2, ensure_ascii=False)
        
        return {
            "status": "success",
            "file_path": str(output)
        }
    except Exception as e:
        return {
            "status": "error",
            "error": str(e)
        }


def save_text_file(content: str, output_path: str) -> dict:
    """
    Save text content to file.
    
    Args:
        content (str): Text content to save
        output_path (str): Path to save the file
        
    Returns:
        dict: Dictionary with status and file path
    """
    try:
        output = Path(output_path)
        output.parent.mkdir(parents=True, exist_ok=True)
        
        with open(output, 'w', encoding='utf-8') as f:
            f.write(content)
        
        return {
            "status": "success",
            "file_path": str(output)
        }
    except Exception as e:
        return {
            "status": "error",
            "error": str(e)
        }


def create_output_directory(base_dir: str = "outputs") -> dict:
    """
    Create timestamped output directory.
    
    Args:
        base_dir (str): Base directory for outputs
        
    Returns:
        dict: Dictionary with status and directory path
    """
    try:
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        output_dir = Path(base_dir) / timestamp
        output_dir.mkdir(parents=True, exist_ok=True)
        
        return {
            "status": "success",
            "directory": str(output_dir)
        }
    except Exception as e:
        return {
            "status": "error",
            "error": str(e)
        }


def clean_json_response(response: str) -> str:
    """
    Clean AI response to extract valid JSON.
    
    Args:
        response (str): Raw AI response
        
    Returns:
        str: Cleaned JSON string
    """
    response = response.strip()
    
    # Remove markdown code blocks
    if response.startswith("```json"):
        response = response[7:]
    elif response.startswith("```"):
        response = response[3:]
    
    if response.endswith("```"):
        response = response[:-3]
    
    return response.strip()


def parse_json_response(response: str) -> dict:
    """
    Parse AI response as JSON with error handling.
    
    Args:
        response (str): Raw AI response
        
    Returns:
        dict: Parsed JSON data
        
    Raises:
        ValueError: If JSON parsing fails
    """
    cleaned = clean_json_response(response)
    
    try:
        return json.loads(cleaned)
    except json.JSONDecodeError as e:
        print(f"Error parsing JSON response: {e}")
        print(f"Response was: {cleaned[:500]}")
        raise ValueError("Failed to parse AI response as JSON")