scripts/generate_prompts.py

#!/usr/bin/env python3
"""
LLMVulnBench Prompt Generator

This script generates prompts from task definitions and prompt templates.
For each task, it iterates over supported languages and prompt types,
validates required variables, and generates final prompts.

Usage:
    python generate_prompts.py

Output:
    - Individual prompt files in ../generated/
    - CSV index in ../generated/prompts_index.csv
    - This repository has already generated prompts for all tasks, so you can skip the generation step.
"""

import json
import os
import csv
from pathlib import Path
from typing import Dict, List, Any


class PromptGenerator:
    def __init__(self, tasks_dir: str, templates_file: str, output_dir: str, generate_files: bool = True):
        self.tasks_dir = Path(tasks_dir)
        self.templates_file = Path(templates_file)
        self.output_dir = Path(output_dir)
        self.generate_files = generate_files
        
        # Create output directory if it doesn't exist
        self.output_dir.mkdir(parents=True, exist_ok=True)
        
        # Storage
        self.tasks = []
        self.templates = {}
        self.generated_prompts = []
        
    def load_tasks(self):
        """Load all task JSON files from tasks directory.
        
        Each JSON file represents a domain and contains an array of tasks.
        """
        print(f"Loading tasks from {self.tasks_dir}...")
        
        domain_files = sorted(self.tasks_dir.glob("*.json"))
        
        for domain_file in domain_files:
            with open(domain_file, 'r') as f:
                domain_data = json.load(f)
                domain_name = domain_data['domain']
                tasks_in_domain = domain_data['tasks']
                
                print(f"  ✓ Loaded domain: {domain_name} ({len(tasks_in_domain)} tasks)")
                
                # Add domain to each task for reference
                for task in tasks_in_domain:
                    task['domain'] = domain_name
                    self.tasks.append(task)
        
        print(f"\nTotal tasks loaded: {len(self.tasks)}\n")
    
    def load_templates(self):
        """Load prompt templates."""
        print(f"Loading templates from {self.templates_file}...")
        
        with open(self.templates_file, 'r') as f:
            self.templates = json.load(f)
        
        for template_name in self.templates:
            print(f"Loaded template: {template_name}")
        
        print(f"\nTotal templates loaded: {len(self.templates)}\n")
    
    def validate_variables(self, task_id: str, language: str, 
                          template_name: str, variables: Dict[str, str]) -> bool:
        """Check if all required variables are present."""
        template = self.templates[template_name]
        required_vars = template['required_vars']
        
        missing_vars = [var for var in required_vars if var not in variables]
        
        if missing_vars:
            print(f"WARNING: {task_id}/{language}/{template_name} missing vars: {missing_vars}")
            return False
        
        return True
    
    def render_prompt(self, template_name: str, variables: Dict[str, str]) -> str:
        """Render a prompt template with variables."""
        template = self.templates[template_name]
        template_string = template['template']
        
        # Use .format() to replace {variable} placeholders
        rendered = template_string.format(**variables)
        
        return rendered
    
    def generate_all_prompts(self):
        """Main generation loop: iterate over tasks, languages, and prompt types."""
        print("=" * 80)
        print("GENERATING PROMPTS")
        print("=" * 80 + "\n")
        
        total_generated = 0
        total_skipped = 0
        
        for task in self.tasks:
            task_id = task['task_id']
            domain = task['domain']
            description = task['description']
            complexity = task['complexity_level']
            risk_tags = task['risk_tags']
            
            print(f"Processing {task_id} ({domain})...")
            
            for language in task['supported_languages']:
                # Get language-specific variables
                lang_vars = task['variables'][language]
                
                for template_name in self.templates.keys():
                    # Merge variables: language, description, + all lang_vars
                    variables = {
                        'language': language,
                        'description': description,
                        **lang_vars
                    }
                    
                    # Validate required variables
                    if not self.validate_variables(task_id, language, template_name, variables):
                        total_skipped += 1
                        continue
                    
                    # Render prompt
                    prompt_text = self.render_prompt(template_name, variables)
                    
                    # Create organized file path: domain/task_id/language_prompttype.txt
                    # Convert domain name to folder-safe format (e.g., "web/api" -> "web_api")
                    domain_folder = domain.replace('/', '_')
                    task_folder = self.output_dir / domain_folder / task_id
                    filename = f"{language}_{template_name}.txt"
                    relative_path = f"{domain_folder}/{task_id}/{filename}"
                    
                    # Save to file if enabled
                    if self.generate_files:
                        task_folder.mkdir(parents=True, exist_ok=True)
                        filepath = task_folder / filename
                        with open(filepath, 'w') as f:
                            f.write(prompt_text)
                    
                    # Store metadata for CSV
                    self.generated_prompts.append({
                        'task_id': task_id,
                        'domain': domain,
                        'language': language,
                        'prompt_type': template_name,
                        'complexity_level': complexity,
                        'risk_tags': ', '.join(risk_tags),
                        'prompt_text': prompt_text,
                        'file_path': relative_path
                    })
                    
                    total_generated += 1
                    print(f"  ✓ {language}/{template_name}")
            
            print()
        
        print("=" * 80)
        print(f"GENERATION COMPLETE")
        print(f"  Total prompts generated: {total_generated}")
        print(f"  Total prompts skipped: {total_skipped}")
        if self.generate_files:
            print(f"  Files saved to organized folders")
        else:
            print(f"  File generation skipped (CSV only)")
        print("=" * 80 + "\n")
    
    def save_csv_index(self):
        """Save all generated prompts to a CSV index."""
        csv_path = self.output_dir / "prompts_index.csv"
        
        print(f"Saving CSV index to {csv_path}...")
        
        with open(csv_path, 'w', newline='', encoding='utf-8') as f:
            if self.generated_prompts:
                fieldnames = self.generated_prompts[0].keys()
                writer = csv.DictWriter(f, fieldnames=fieldnames)
                
                writer.writeheader()
                writer.writerows(self.generated_prompts)
        
        print(f"  ✓ CSV index saved with {len(self.generated_prompts)} entries\n")
    
    def print_summary(self):
        """Print generation summary statistics."""
        if not self.generated_prompts:
            print("No prompts generated.")
            return
        
        # Count by domain
        domains = {}
        languages = {}
        prompt_types = {}
        
        for prompt in self.generated_prompts:
            domain = prompt['domain']
            lang = prompt['language']
            ptype = prompt['prompt_type']
            
            domains[domain] = domains.get(domain, 0) + 1
            languages[lang] = languages.get(lang, 0) + 1
            prompt_types[ptype] = prompt_types.get(ptype, 0) + 1
        
        print("=" * 80)
        print("SUMMARY STATISTICS")
        print("=" * 80)
        print(f"\nTotal Prompts: {len(self.generated_prompts)}\n")
        
        print("By Domain:")
        for domain, count in sorted(domains.items()):
            print(f"  {domain}: {count}")
        
        print("\nBy Language:")
        for lang, count in sorted(languages.items()):
            print(f"  {lang}: {count}")
        
        print("\nBy Prompt Type:")
        for ptype, count in sorted(prompt_types.items()):
            print(f"  {ptype}: {count}")
        
        print("\n" + "=" * 80 + "\n")
    
    def run(self):
        """Run the full generation pipeline."""
        self.load_tasks()
        self.load_templates()
        self.generate_all_prompts()
        self.save_csv_index()
        self.print_summary()


def main():
    import sys
    
    # Define paths relative to script location
    script_dir = Path(__file__).parent
    project_root = script_dir.parent
    
    tasks_dir = project_root / "tasks"
    templates_file = project_root / "prompts" / "templates.json"
    output_dir = project_root / "generated"
    
    # Check for command-line flag to disable file generation
    generate_files = True
    if len(sys.argv) > 1 and sys.argv[1] == "--csv-only":
        generate_files = False
        print("Running in CSV-only mode (no individual files will be generated)\n")
    
    # Create and run generator
    generator = PromptGenerator(
        tasks_dir=str(tasks_dir),
        templates_file=str(templates_file),
        output_dir=str(output_dir),
        generate_files=generate_files
    )
    
    generator.run()


if __name__ == "__main__":
    main()