"""
Asymmetric PPO Implementation
"""
import torch
import torch.nn as nn
import torch.nn.functional as F

class AsymmetricPPO(nn.Module):
    def __init__(self, action_dim, obs_dim, hidden_dim=1024, traj_dim=2048):
        super().__init__()
        self.actor = nn.Sequential(
            nn.Linear(obs_dim, hidden_dim), nn.GELU(),
            nn.Linear(hidden_dim, hidden_dim), nn.GELU(),
            nn.Linear(hidden_dim, action_dim)
        )
        self.critic = nn.Sequential(
            nn.Linear(traj_dim, hidden_dim), nn.GELU(),
            nn.Linear(hidden_dim, hidden_dim), nn.GELU(),
            nn.Linear(hidden_dim, 1)
        )
    
    def get_action(self, obs):
        logits = self.actor(obs)
        probs = F.softmax(logits, dim=-1)
        dist = torch.distributions.Categorical(probs)
        return dist.sample(), dist.log_prob(dist.sample())

# Training simulation
print("=== Asymmetric PPO Training ===")
print("\nInference phase (current observation only):")
print("  Step 1: Analyze repo structure → locate src/models/checkout.go")
print("  Step 2: Read existing code → understand coupon logic")
print("  Step 3: Modify price function → add validation")
print("  Step 4: Run tests → failed (edge case uncovered)")
print("  Step 5: Read error → identify missing discount cap")
print("  Step 6: Fix → add upper limit check")
print("  Step 7: Re-run tests → all passed ✅")
print("  Step 8: Generate commit → task complete")

package main

import (
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"sync"
	"time"
)

type LanguageConfig struct {
	DependencyFile string
	BuildCmd      string
	TestCmd       string
}

var configs = map[string]LanguageConfig{
	"go":   {"go.mod", "go build ./...", "go test ./..."},
	"python": {"requirements.txt", "pip install -r requirements.txt", "pytest"},
	"rust": {"Cargo.toml", "cargo build", "cargo test"},
}

type RepoEnvironment struct {
	Path     string
	Language string
	BuildOK  bool
	TestOK   bool
	BuildLog string
}

type AutoBuilder struct {
	mu            sync.Mutex
	successCount  int
	totalCount    int
	recoveredCount int
}

func (ab *AutoBuilder) BuildRepo(repoPath string) (*RepoEnvironment, error) {
	lang := detectLanguage(repoPath)
	config := configs[lang]
	repo := &RepoEnvironment{Path: repoPath, Language: lang}

	cmd := exec.Command("bash", "-c", config.BuildCmd+" && "+config.TestCmd)
	cmd.Dir = repoPath
	output, err := cmd.CombinedOutput()
	repo.BuildLog = string(output)
	repo.BuildOK = err == nil
	repo.TestOK = strings.Contains(repo.BuildLog, "PASS") || 
	               strings.Contains(repo.BuildLog, "OK")

	ab.mu.Lock()
	ab.totalCount++
	if repo.BuildOK && repo.TestOK {
		ab.successCount++
	}
	ab.mu.Unlock()

	fmt.Printf("[AutoBuilder] %s: build=%v, test=%v, time=%v\n",
		filepath.Base(repoPath), repo.BuildOK, repo.TestOK, time.Since(start))
	return repo, nil
}

func detectLanguage(path string) string {
	for lang, cfg := range configs {
		if _, err := os.Stat(filepath.Join(path, cfg.DependencyFile)); err == nil {
			return lang
		}
	}
	return "unknown"
}

func (ab *AutoBuilder) Report() {
	rate := float64(ab.successCount+ab.recoveredCount) / float64(ab.totalCount) * 100
	fmt.Printf("\nAutoBuilder: %d/%d success (%.1f%%), recovered=%d\n",
		ab.successCount, ab.totalCount, rate, ab.recoveredCount)
}

var start = time.Now()

func main() {
	builder := &AutoBuilder{}
	builder.BuildRepo("/tmp/repos/go-webapp")
	builder.Report()
}