rockman/cli/__init__.py

"""CLI commands for Rockman benchmark"""

import json
import os
import sys
from pathlib import Path
from typing import List, Dict, Optional
import argparse

from rockman.benchmark.schema import Problem, TaskType, Language
from rockman.benchmark.evaluator import Evaluator
from rockman.benchmark.metrics import (
    aggregate_scores,
    BenchmarkReport,
    print_leaderboard_header,
    format_leaderboard_row,
)
from rockman.benchmark.versioning import VersionRegistry, CURRENT_VERSION
from rockman.dataset.generator import generate_benchmark_dataset, get_all_templates
from rockman.dataset.validators import validate_dataset, generate_validation_report
from rockman.dataset.splits import SplitManager, create_canary_strings
from rockman.benchmark.encryption import HiddenTestEncryption, generate_master_secret


def load_problems_from_jsonl(filepath: str, include_hidden: bool = False) -> List[Problem]:
    """Load problems from JSONL file."""
    problems = []
    with open(filepath, "r", encoding="utf-8") as f:
        for line in f:
            line = line.strip()
            if not line:
                continue
            data = json.loads(line)
            if not include_hidden:
                data.pop("hidden_test_encrypted", None)
                data.pop("hidden_test_nonce", None)
                data.pop("hidden_test_tag", None)
            problems.append(Problem.from_dict(data))
    return problems


def save_problems_to_jsonl(problems: List[Problem], filepath: str, include_hidden: bool = False):
    """Save problems to JSONL file."""
    with open(filepath, "w", encoding="utf-8") as f:
        for problem in problems:
            f.write(problem.to_jsonl(include_hidden=include_hidden) + "\n")


def cmd_generate(args):
    """Generate benchmark dataset."""
    print(f"Generating Rockman benchmark dataset {args.version}...")

    encryption = None
    if args.encrypt_hidden:
        master_secret = os.environ.get("ROCKMAN_MASTER_SECRET") or generate_master_secret()
        if not os.environ.get("ROCKMAN_MASTER_SECRET"):
            print(f"Generated master secret (save this!): {master_secret}")
            print("Set ROCKMAN_MASTER_SECRET environment variable to use it.")
        encryption = HiddenTestEncryption(master_secret, args.version)

    problems = generate_benchmark_dataset(
        target_count=args.count,
        version=args.version,
        encryption=encryption,
    )

    output_path = args.output or f"rockman_dataset_{args.count}.jsonl"
    # Always include hidden tests when encrypting, otherwise use flag
    include_hidden = args.include_hidden or args.encrypt_hidden
    save_problems_to_jsonl(problems, output_path, include_hidden=include_hidden)
    print(f"Generated {len(problems)} problems -> {output_path}")

    if args.validate:
        print("\nValidating dataset...")
        results = validate_dataset(problems)
        report = generate_validation_report(results)
        print(report)

    if args.create_splits:
        print("\nCreating standard splits...")
        split_manager = SplitManager()
        splits = split_manager.create_standard_splits(problems, args.version)
        for name, split in splits.items():
            print(f"  {name}: {len(split.task_ids)} tasks")


def cmd_evaluate(args):
    """Evaluate model outputs against benchmark."""
    print(f"Loading dataset from {args.dataset}...")
    problems = load_problems_from_jsonl(args.dataset, include_hidden=args.include_hidden)

    if args.problem_ids:
        problem_ids = set(args.problem_ids.split(","))
        problems = [p for p in problems if p.task_id in problem_ids]

    print(f"Evaluating {len(problems)} problems...")

    # Load model completions
    completions = {}
    if args.completions_file:
        with open(args.completions_file) as f:
            completions = json.load(f)
    else:
        print("No completions file provided. Use --completions-file.")
        return

    evaluator = Evaluator(benchmark_version=args.version)
    results = evaluator.evaluate_dataset(
        problems,
        completions,
        include_hidden=args.include_hidden,
        k=args.k,
    )

    print(f"\nMean Pass@{args.k}: {results['mean_pass_at_k']:.4f}")
    print(f"Evaluated: {results['evaluated_count']}/{len(problems)}")

    if args.detailed:
        for task_id, task_results in results["results"].items():
            passed = sum(1 for r in task_results if r.passed)
            total = len(task_results)
            print(f"  {task_id}: {passed}/{total} passed")


def cmd_leaderboard(args):
    """Generate leaderboard from evaluation results."""
    print_leaderboard_header()

    # Load evaluation results
    with open(args.results_file) as f:
        eval_results = json.load(f)

    for model_name, result in eval_results.items():
        score = BenchmarkReport(**result).score
        row = format_leaderboard_row(
            model_name=model_name,
            model_version=result.get("model_version", "unknown"),
            score=score,
            temperature=result.get("temperature", 0.2),
            max_tokens=result.get("max_tokens", 4096),
            attempts=result.get("num_attempts", 1),
            hardware=result.get("hardware", "unknown"),
            date=result.get("date", ""),
        )
        print(row)


def cmd_publish(args):
    """Prepare dataset for publication."""
    print(f"Preparing publication from {args.dataset}...")

    problems = load_problems_from_jsonl(args.dataset, include_hidden=True)

    # Create splits if needed
    split_manager = SplitManager(args.splits_dir)
    if "public" not in split_manager.splits:
        print("Creating standard splits...")
        split_manager.create_standard_splits(problems, args.version)

    # Export public dataset (no hidden tests)
    if args.public_output:
        split_manager.export_public_dataset(
            problems, args.public_output, "public", include_hidden=False
        )
        print(f"Public dataset -> {args.public_output}")

    # Export private dataset (with encrypted hidden tests)
    if args.private_output:
        master_secret = os.environ.get("ROCKMAN_MASTER_SECRET")
        if not master_secret:
            print("ERROR: ROCKMAN_MASTER_SECRET required for private dataset")
            return
        split_manager.export_private_dataset(
            problems, args.private_output, "private", master_secret
        )
        print(f"Private dataset -> {args.private_output}")

    # Export hidden dataset (never published)
    if args.hidden_output:
        split_manager.export_hidden_dataset(
            problems, args.hidden_output, "hidden"
        )
        print(f"Hidden dataset -> {args.hidden_output}")

    # Generate canary strings
    if args.canary_output:
        canaries = create_canary_strings(problems)
        with open(args.canary_output, "w") as f:
            json.dump(canaries, f, indent=2)
        print(f"Canary strings -> {args.canary_output}")

    # Verify no overlap
    overlaps = split_manager.verify_no_overlap()
    if overlaps:
        print("WARNING: Split overlaps detected:")
        for o in overlaps:
            print(f"  {o}")
    else:
        print("Split integrity: OK - no overlaps")

    # Compute hashes
    hashes = split_manager.compute_split_hashes(problems)
    print("Split hashes:")
    for name, h in hashes.items():
        print(f"  {name}: {h}")


def cmd_validate(args):
    """Validate dataset quality."""
    print(f"Validating {args.dataset}...")
    problems = load_problems_from_jsonl(args.dataset, include_hidden=True)

    if args.problem_ids:
        problem_ids = set(args.problem_ids.split(","))
        problems = [p for p in problems if p.task_id in problem_ids]

    print(f"Validating {len(problems)} problems...")

    solutions = {}
    if args.solutions_file:
        with open(args.solutions_file) as f:
            solutions = json.load(f)

    buggy = {}
    if args.buggy_file:
        with open(args.buggy_file) as f:
            buggy = json.load(f)

    results = validate_dataset(problems, solutions, buggy)
    report = generate_validation_report(results)
    print(report)

    if args.output:
        with open(args.output, "w") as f:
            json.dump({k: v.__dict__ for k, v in results.items()}, f, indent=2)


def cmd_encrypt(args):
    """Encrypt hidden tests in dataset."""
    master_secret = os.environ.get("ROCKMAN_MASTER_SECRET")
    if not master_secret:
        print("ERROR: ROCKMAN_MASTER_SECRET environment variable required")
        return

    encryption = HiddenTestEncryption(master_secret, args.version)

    problems = load_problems_from_jsonl(args.input, include_hidden=True)
    for problem in problems:
        if problem.metadata.get("_hidden_test_raw"):
            problem = encryption.encrypt_problem_hidden_tests(problem)

    save_problems_to_jsonl(problems, args.output, include_hidden=True)
    print(f"Encrypted {len(problems)} problems -> {args.output}")


def cmd_decrypt(args):
    """Decrypt hidden tests (for evaluation server)."""
    master_secret = os.environ.get("ROCKMAN_MASTER_SECRET")
    if not master_secret:
        print("ERROR: ROCKMAN_MASTER_SECRET environment variable required")
        return

    encryption = HiddenTestEncryption(master_secret, args.version)

    problems = load_problems_from_jsonl(args.input, include_hidden=True)
    for problem in problems:
        if problem.hidden_test_encrypted:
            hidden = encryption.decrypt_problem_hidden_tests(problem)
            print(f"{problem.task_id}:")
            print(hidden)
            print("---")


def cmd_version(args):
    """Manage benchmark versions."""
    registry = VersionRegistry()

    if args.list:
        for v in registry.list_versions():
            print(f"{v.version}: {v.task_count} tasks - {v.description}")
    elif args.register:
        task_ids = args.task_ids.split(",") if args.task_ids else []
        registry.register(args.register, task_ids, args.description, args.parent)
        print(f"Registered version {args.register}")
    elif args.verify:
        problems = load_problems_from_jsonl(args.dataset)
        task_ids = {p.task_id for p in problems}
        if registry.verify_integrity(args.verify, task_ids):
            print(f"Version {args.verify} integrity: OK")
        else:
            print(f"Version {args.verify} integrity: FAILED")
    else:
        print("Use --list, --register, or --verify")


def main():
    parser = argparse.ArgumentParser(prog="rockman", description="Rockman Benchmark CLI")
    subparsers = parser.add_subparsers(dest="command", required=True)

    # generate
    gen_parser = subparsers.add_parser("generate", help="Generate benchmark dataset")
    gen_parser.add_argument("--count", type=int, default=500, help="Number of problems to generate")
    gen_parser.add_argument("--version", default=CURRENT_VERSION, help="Benchmark version")
    gen_parser.add_argument("--output", help="Output JSONL file")
    gen_parser.add_argument("--encrypt-hidden", action="store_true", help="Encrypt hidden tests")
    gen_parser.add_argument("--include-hidden", action="store_true", help="Include hidden tests in output")
    gen_parser.add_argument("--validate", action="store_true", help="Validate after generation")
    gen_parser.add_argument("--create-splits", action="store_true", help="Create public/private/hidden splits")
    gen_parser.set_defaults(func=cmd_generate)

    # evaluate
    eval_parser = subparsers.add_parser("evaluate", help="Evaluate model completions")
    eval_parser.add_argument("--dataset", required=True, help="Dataset JSONL file")
    eval_parser.add_argument("--completions-file", required=True, help="Model completions JSON file")
    eval_parser.add_argument("--version", default=CURRENT_VERSION, help="Benchmark version")
    eval_parser.add_argument("--k", type=int, default=1, help="Pass@k value")
    eval_parser.add_argument("--include-hidden", action="store_true", help="Include hidden tests")
    eval_parser.add_argument("--problem-ids", help="Comma-separated problem IDs to evaluate")
    eval_parser.add_argument("--detailed", action="store_true", help="Show per-problem results")
    eval_parser.set_defaults(func=cmd_evaluate)

    # leaderboard
    lb_parser = subparsers.add_parser("leaderboard", help="Generate leaderboard")
    lb_parser.add_argument("--results-file", required=True, help="Evaluation results JSON file")
    lb_parser.set_defaults(func=cmd_leaderboard)

    # publish
    pub_parser = subparsers.add_parser("publish", help="Prepare dataset for publication")
    pub_parser.add_argument("--dataset", required=True, help="Dataset JSONL file")
    pub_parser.add_argument("--version", default=CURRENT_VERSION, help="Benchmark version")
    pub_parser.add_argument("--splits-dir", default="rockman_splits", help="Splits directory")
    pub_parser.add_argument("--public-output", help="Public dataset output path")
    pub_parser.add_argument("--private-output", help="Private dataset output path")
    pub_parser.add_argument("--hidden-output", help="Hidden dataset output path")
    pub_parser.add_argument("--canary-output", help="Canary strings output path")
    pub_parser.set_defaults(func=cmd_publish)

    # validate
    val_parser = subparsers.add_parser("validate", help="Validate dataset quality")
    val_parser.add_argument("--dataset", required=True, help="Dataset JSONL file")
    val_parser.add_argument("--solutions-file", help="Reference solutions JSON file")
    val_parser.add_argument("--buggy-file", help="Buggy solutions JSON file")
    val_parser.add_argument("--problem-ids", help="Comma-separated problem IDs to validate")
    val_parser.add_argument("--output", help="Validation results output file")
    val_parser.set_defaults(func=cmd_validate)

    # encrypt
    enc_parser = subparsers.add_parser("encrypt", help="Encrypt hidden tests")
    enc_parser.add_argument("--input", required=True, help="Input JSONL file")
    enc_parser.add_argument("--output", required=True, help="Output JSONL file")
    enc_parser.add_argument("--version", default=CURRENT_VERSION, help="Benchmark version")
    enc_parser.set_defaults(func=cmd_encrypt)

    # decrypt
    dec_parser = subparsers.add_parser("decrypt", help="Decrypt hidden tests")
    dec_parser.add_argument("--input", required=True, help="Input JSONL file")
    dec_parser.add_argument("--version", default=CURRENT_VERSION, help="Benchmark version")
    dec_parser.set_defaults(func=cmd_decrypt)

    # version
    ver_parser = subparsers.add_parser("version", help="Manage benchmark versions")
    ver_parser.add_argument("--list", action="store_true", help="List all versions")
    ver_parser.add_argument("--register", help="Register new version")
    ver_parser.add_argument("--task-ids", help="Comma-separated task IDs for new version")
    ver_parser.add_argument("--description", help="Version description")
    ver_parser.add_argument("--parent", help="Parent version")
    ver_parser.add_argument("--verify", help="Verify version integrity")
    ver_parser.add_argument("--dataset", help="Dataset for verification")
    ver_parser.set_defaults(func=cmd_version)

    args = parser.parse_args()
    args.func(args)


if __name__ == "__main__":
    main()