adversarial_coding.py

"""
Adversarial Coding - Apply adversarial protocol to actual code generation with validation gates
"""
from coding_agent_wrapper import CodingAgentWrapper, validate_component, ValidationResult
from typing import Optional
import json
import time

def adversarial_build(
    task: str,
    workdir: str,
    max_rounds: int = 3,
    agent_type: str = "codex",
    verbose: bool = False
) -> dict:
    """
    Build a component using adversarial protocol with validation gates.
    
    Process:
    1. Proposer builds the component
    2. Validate (run tests, health checks)
    3. If validation fails, Attacker reviews and finds issues
    4. Proposer fixes issues
    5. Repeat until validation passes or max_rounds reached
    
    Args:
        task: Description of what to build
        workdir: Working directory for the build
        max_rounds: Maximum attack/defend rounds
        agent_type: Type of coding agent (claude, codex)
        verbose: Print detailed output
        
    Returns:
        {
            "success": bool,
            "rounds": int,
            "validation": ValidationResult.to_dict(),
            "workdir": str,
            "conversation": [...],
            "final_critique": str
        }
    """
    print(f"\n{'='*70}")
    print(f"🏗️  ADVERSARIAL BUILD")
    print(f"{'='*70}")
    print(f"Task: {task}")
    print(f"Workdir: {workdir}")
    print(f"Max rounds: {max_rounds}")
    print(f"{'='*70}\n")
    
    # Create proposer and attacker agents
    proposer = CodingAgentWrapper(workdir=workdir, agent_type=agent_type)
    
    conversation = []
    validation_result = None
    
    for round_num in range(1, max_rounds + 1):
        print(f"\n{'='*70}")
        print(f"🔄 ROUND {round_num}/{max_rounds}")
        print(f"{'='*70}\n")
        
        if round_num == 1:
            # Initial build
            proposer_prompt = f"""Build this component:

{task}

REQUIREMENTS:
1. Create all necessary code files
2. Write comprehensive tests (unit + edge cases)
3. Create a health check script that validates the component works
4. Add a README with setup instructions

Make it production-ready for 1M users scale."""
            
        else:
            # Fix issues from previous round
            proposer_prompt = f"""Previous attempt had issues:

{attacker_critique}

Fix ALL the issues mentioned. Update code, add missing tests, handle edge cases."""
        
        print("👷 PROPOSER: Building...")
        if verbose:
            print(f"\nPrompt: {proposer_prompt}\n")
        
        start = time.time()
        proposer_response = proposer.run(proposer_prompt, timeout=300)
        elapsed = time.time() - start
        
        print(f"✓ Proposer completed in {elapsed:.1f}s")
        
        if verbose:
            print(f"\nProposer output:\n{proposer_response[:500]}...\n")
        
        conversation.append({
            "round": round_num,
            "role": "proposer",
            "prompt": proposer_prompt,
            "response": proposer_response,
            "elapsed": elapsed
        })
        
        # VALIDATION GATE
        print("\n🔍 VALIDATING...")
        validation_result = validate_component(proposer)
        print(validation_result.summary())
        
        if validation_result.is_complete():
            print(f"\n✅ COMPONENT COMPLETE after {round_num} round(s)")
            break
        
        # Validation failed - get attacker critique
        print("\n⚔️  ATTACKER: Reviewing failures...")
        
        # Build context for attacker
        context = proposer.get_context()
        
        attacker_prompt = f"""Review this code that FAILED validation:

{context}

VALIDATION RESULTS:
{validation_result.summary()}

TEST OUTPUT:
{validation_result.test_output[:500] if validation_result.test_output else 'No tests run'}

Your job: Find ALL the issues. Be thorough and specific.

Focus on:
1. Why tests are failing (or missing)
2. Edge cases not handled
3. Security vulnerabilities
4. Performance issues for 1M users scale
5. Missing error handling

List at least 3-5 concrete issues with file names and line references."""
        
        if verbose:
            print(f"\nAttacker prompt: {attacker_prompt[:300]}...\n")
        
        # Use a fresh agent for attacker (different perspective)
        attacker = CodingAgentWrapper(workdir=workdir, agent_type=agent_type)
        
        start = time.time()
        attacker_critique = attacker.run(attacker_prompt, timeout=180)
        elapsed = time.time() - start
        
        print(f"✓ Attacker completed in {elapsed:.1f}s")
        
        if verbose:
            print(f"\nAttacker critique:\n{attacker_critique[:500]}...\n")
        
        conversation.append({
            "round": round_num,
            "role": "attacker",
            "prompt": attacker_prompt,
            "response": attacker_critique,
            "elapsed": elapsed,
            "validation": validation_result.to_dict()
        })
        
        # Continue to next round with fixes
        print(f"\n⚠️  Issues found. Moving to round {round_num + 1}...")
    
    # Final result
    success = validation_result is not None and validation_result.is_complete()
    
    result = {
        "success": success,
        "rounds": round_num,
        "validation": validation_result.to_dict() if validation_result else {},
        "workdir": str(proposer.workdir),
        "conversation": conversation,
        "files_created": proposer.list_files(),
        "final_critique": attacker_critique if not success else "All validation checks passed"
    }
    
    # Save state
    state_file = f"{workdir}/adversarial_build_state.json"
    with open(state_file, 'w') as f:
        json.dump(result, f, indent=2)
    print(f"\n📝 Build state saved to: {state_file}")
    
    return result


def build_with_baseline(
    task: str,
    workdir: str,
    agent_type: str = "codex",
    verbose: bool = False
) -> dict:
    """
    Build component with single agent (baseline for comparison).
    
    Returns same format as adversarial_build for comparison.
    """
    print(f"\n{'='*70}")
    print(f"📦 BASELINE BUILD (Single Agent)")
    print(f"{'='*70}")
    print(f"Task: {task}")
    print(f"Workdir: {workdir}")
    print(f"{'='*70}\n")
    
    agent = CodingAgentWrapper(workdir=workdir, agent_type=agent_type)
    
    prompt = f"""Build this component:

{task}

REQUIREMENTS:
1. Create all necessary code files
2. Write comprehensive tests (unit + edge cases)
3. Create a health check script that validates the component works
4. Add a README with setup instructions

Make it production-ready for 1M users scale."""
    
    print("👷 AGENT: Building...")
    if verbose:
        print(f"\nPrompt: {prompt}\n")
    
    start = time.time()
    response = agent.run(prompt, timeout=300)
    elapsed = time.time() - start
    
    print(f"✓ Agent completed in {elapsed:.1f}s")
    
    if verbose:
        print(f"\nAgent output:\n{response[:500]}...\n")
    
    # Validate
    print("\n🔍 VALIDATING...")
    validation_result = validate_component(agent)
    print(validation_result.summary())
    
    result = {
        "success": validation_result.is_complete(),
        "rounds": 1,
        "validation": validation_result.to_dict(),
        "workdir": str(agent.workdir),
        "conversation": [{
            "round": 1,
            "role": "agent",
            "prompt": prompt,
            "response": response,
            "elapsed": elapsed
        }],
        "files_created": agent.list_files()
    }
    
    # Save state
    state_file = f"{workdir}/baseline_build_state.json"
    with open(state_file, 'w') as f:
        json.dump(result, f, indent=2)
    print(f"\n📝 Build state saved to: {state_file}")
    
    return result


if __name__ == "__main__":
    import sys
    import argparse
    
    parser = argparse.ArgumentParser(description="Build code with adversarial validation")
    parser.add_argument("task", help="What to build")
    parser.add_argument("--workdir", required=True, help="Working directory")
    parser.add_argument("--rounds", type=int, default=3, help="Max validation rounds")
    parser.add_argument("--baseline", action="store_true", help="Run baseline (single agent)")
    parser.add_argument("--agent", default="codex", choices=["claude", "codex"], 
                       help="Agent type (default: codex)")
    parser.add_argument("--verbose", "-v", action="store_true", help="Verbose output")
    
    args = parser.parse_args()
    
    if args.baseline:
        result = build_with_baseline(
            args.task,
            args.workdir,
            agent_type=args.agent,
            verbose=args.verbose
        )
    else:
        result = adversarial_build(
            args.task,
            args.workdir,
            max_rounds=args.rounds,
            agent_type=args.agent,
            verbose=args.verbose
        )
    
    print(f"\n{'='*70}")
    print(f"🎯 FINAL RESULT: {'✅ SUCCESS' if result['success'] else '❌ INCOMPLETE'}")
    print(f"{'='*70}")
    print(f"Rounds: {result['rounds']}")
    print(f"Files created: {len(result['files_created'])}")
    print(f"Workdir: {result['workdir']}")
    
    sys.exit(0 if result['success'] else 1)