Anthropic's Recursive Self-Improvement Warning: When AI Learns to "Self-Evolve", How Much Time Does Humanity Have?

"""
Agent Autonomous Iteration Framework - Python Implementation
Test-driven automated code iteration and optimization
"""

import asyncio
import hashlib
import time
from dataclasses import dataclass, field
from enum import Enum
from typing import Any, Callable, Optional
from datetime import datetime
import json


class IterationStatus(Enum):
    """Iteration status enum"""
    PENDING = "pending"
    RUNNING = "running"
    SUCCESS = "success"
    FAILED = "failed"
    TIMEOUT = "timeout"
    HUMAN_REVIEW = "human_review"


@dataclass
class TestCase:
    """Test case definition"""
    name: str
    description: str
    test_func: Callable[[], bool]
    timeout_seconds: int = 60
    priority: int = 1


@dataclass
class IterationResult:
    """Iteration result data"""
    iteration_id: str
    status: IterationStatus
    code_changes: str
    test_results: dict[str, bool]
    performance_metrics: dict[str, float]
    duration_seconds: float
    ai_explanation: str = ""
    timestamp: str = field(default_factory=lambda: datetime.now().isoformat())


class TestDrivenIterationFramework:
    """
    Test-Driven Iteration Framework
    
    Core Principles:
    1. Test pass rates and performance metrics drive iteration signals
    2. Agents autonomously complete multiple iteration rounds
    3. Humans intervene only at critical checkpoints
    4. Each iteration generates explainable code diff reports
    """
    
    def __init__(
        self,
        model_name: str = "claude-sonnet-4-20250514",
        max_iterations: int = 100,
        improvement_threshold: float = 0.01,
        human_review_interval: int = 10
    ):
        self.model_name = model_name
        self.max_iterations = max_iterations
        self.improvement_threshold = improvement_threshold
        self.human_review_interval = human_review_interval
        
        self.test_suite: list[TestCase] = []
        self.iteration_history: list[IterationResult] = []
        self.current_code: str = ""
        self.performance_baseline: dict[str, float] = {}
        
    def register_test(self, test: TestCase) -> None:
        """Register a test case"""
        self.test_suite.append(test)
        # Sort by priority
        self.test_suite.sort(key=lambda t: t.priority, reverse=True)
        
    async def run_tests(self, code: str) -> tuple[dict[str, bool], dict[str, float]]:
        """Run test suite and collect performance metrics"""
        test_results = {}
        performance_metrics = {}
        
        for test in self.test_suite:
            try:
                start_time = time.time()
                result = await asyncio.wait_for(
                    asyncio.to_thread(test.test_func),
                    timeout=test.timeout_seconds
                )
                duration = time.time() - start_time
                
                test_results[test.name] = result
                performance_metrics[f"{test.name}_duration"] = duration
                
            except asyncio.TimeoutError:
                test_results[test.name] = False
                performance_metrics[f"{test.name}_duration"] = test.timeout_seconds
            except Exception as e:
                test_results[test.name] = False
                performance_metrics[f"{test.name}_error"] = 1.0
                
        return test_results, performance_metrics
    
    async def generate_code_improvement(
        self,
        current_code: str,
        test_results: dict[str, bool],
        performance_metrics: dict[str, float]
    ) -> tuple[str, str]:
        """
        Generate code improvements
        
        Returns: (improved code, natural language explanation)
        """
        # Build context
        context = self._build_context(current_code, test_results, performance_metrics)
        
        # Simulate Claude API call
        improved_code = await self._call_claude_api(context)
        explanation = self._generate_explanation(test_results, performance_metrics)
        
        return improved_code, explanation
    
    def _build_context(
        self,
        current_code: str,
        test_results: dict[str, bool],
        performance_metrics: dict[str, float]
    ) -> str:
        """Build Claude API context"""
        failed_tests = [name for name, result in test_results.items() if not result]
        
        context = f"""
Current Code:
```{current_code}```

Test Results:
{json.dumps(test_results, indent=2)}

Performance Metrics:
{json.dumps(performance_metrics, indent=2)}

Failed Tests: {failed_tests if failed_tests else 'None'}

Task: Improve the code to make all tests pass while optimizing performance.
Focus on: {', '.join(failed_tests) if failed_tests else 'general improvements'}
"""
        return context
    
    async def _call_claude_api(self, context: str) -> str:
        """Call Claude API to generate improvements"""
        # In real implementation, call Claude API:
        # response = await anthropic.messages.create(
        #     model="claude-sonnet-4-20250514",
        #     max_tokens=4096,
        #     messages=[{"role": "user", "content": context}]
        # )
        
        await asyncio.sleep(0.1)  # Simulate API latency
        return self.current_code  # Return improved code
    
    def _generate_explanation(
        self,
        test_results: dict[str, bool],
        performance_metrics: dict[str, float]
    ) -> str:
        """Generate natural language explanation for code changes"""
        improvements = []
        
        for test_name, passed in test_results.items():
            if passed:
                improvements.append(f"Fixed: {test_name}")
                
        return "; ".join(improvements) if improvements else "General optimization"
    
    async def execute_iteration(
        self,
        iteration_number: int
    ) -> IterationResult:
        """Execute single iteration"""
        iteration_id = hashlib.md5(
            f"{self.current_code}{iteration_number}{time.time()}".encode()
        ).hexdigest()[:12]
        
        # Run tests
        test_results, performance_metrics = await self.run_tests(self.current_code)
        
        # Generate improvement
        improved_code, explanation = await self.generate_code_improvement(
            self.current_code,
            test_results,
            performance_metrics
        )
        
        # Verify in sandbox
        self.current_code = improved_code
        sandbox_results, sandbox_metrics = await self.run_tests(self.current_code)
        
        # Determine status
        all_passed = all(sandbox_results.values())
        status = IterationStatus.SUCCESS if all_passed else IterationStatus.RUNNING
        
        # Require human review
        if iteration_number % self.human_review_interval == 0:
            status = IterationStatus.HUMAN_REVIEW
        
        return IterationResult(
            iteration_id=iteration_id,
            status=status,
            code_changes=diff(self.current_code, improved_code),
            test_results=sandbox_results,
            performance_metrics=sandbox_metrics,
            duration_seconds=sum(v for k, v in sandbox_metrics.items() if 'duration' in k),
            ai_explanation=explanation
        )
    
    async def run_autonomous_iteration(
        self,
        goal: str,
        initial_code: str
    ) -> list[IterationResult]:
        """
        Run autonomous iteration
        
        Args:
            goal: Optimization goal description
            initial_code: Initial code
            
        Returns:
            List of iteration results
        """
        self.current_code = initial_code
        
        # Establish baseline
        baseline_results, baseline_metrics = await self.run_tests(initial_code)
        self.performance_baseline = baseline_metrics
        
        print(f"Starting autonomous iteration for goal: {goal}")
        print(f"Initial test pass rate: {sum(baseline_results.values())}/{len(baseline_results)}")
        
        results = []
        for i in range(1, self.max_iterations + 1):
            print(f"\n--- Iteration {i} ---")
            
            result = await self.execute_iteration(i)
            results.append(result)
            self.iteration_history.append(result)
            
            print(f"Status: {result.status.value}")
            print(f"Tests passed: {sum(result.test_results.values())}/{len(result.test_results)}")
            print(f"Duration: {result.duration_seconds:.2f}s")
            
            # Check if all tests passed
            if result.status == IterationStatus.SUCCESS:
                print("\n✓ All tests passed! Stopping iteration.")
                break
            
            # Check for performance plateau
            if self._check_performance_plateau(result.performance_metrics):
                print("\n⚠ Performance plateau detected. Consider human review.")
                
            # Human review checkpoint
            if result.status == IterationStatus.HUMAN_REVIEW:
                print("\n⏸ Human review required. Pause for intervention.")
        
        return results
    
    def _check_performance_plateau(
        self,
        current_metrics: dict[str, float]
    ) -> bool:
        """Check for performance plateau (diminishing returns)"""
        if len(self.iteration_history) < 2:
            return False
            
        recent_improvements = []
        for i in range(max(0, len(self.iteration_history) - 5), len(self.iteration_history)):
            prev = self.iteration_history[i-1].performance_metrics
            curr = self.iteration_history[i].performance_metrics
            
            for key in prev:
                if key in curr and 'duration' in key:
                    if 'error' not in key:
                        improvement = (prev[key] - curr[key]) / max(prev[key], 0.001)
                        recent_improvements.append(improvement)
        
        if recent_improvements:
            avg_improvement = sum(recent_improvements) / len(recent_improvements)
            return avg_improvement < self.improvement_threshold
        
        return False


def diff(old_code: str, new_code: str) -> str:
    """Generate code diff"""
    return f"Changed {len(new_code) - len(old_code)} characters"

package sandbox

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"os"
	"path/filepath"
	"strings"
	"sync"
	"time"
)

/*
 * Sandbox Execution Environment - Go Implementation
 * 
 * Core Features:
 * 1. Isolated compilation and execution environment
 * 2. Resource limits (CPU, memory, time)
 * 3. Test result collection and reporting
 * 4. Safe code diff comparison
 */

type SandboxConfig struct {
	WorkingDir       string
	MaxMemoryMB      int64
	MaxCPUPercent    int
	TimeoutSeconds   int
	AllowedImports   []string
	NetworkIsolation bool
}

type TestResult struct {
	Name      string            `json:"name"`
	Passed    bool              `json:"passed"`
	Duration  float64           `json:"duration_ms"`
	ErrorMsg  string            `json:"error,omitempty"`
	Metrics   map[string]float64 `json:"metrics,omitempty"`
}

type SandboxResult struct {
	ExitCode    int          `json:"exit_code"`
	TestResults []TestResult `json:"test_results"`
	Output      string       `json:"output"`
	Error       string       `json:"error,omitempty"`
	Duration    float64      `json:"duration_ms"`
	MemoryPeak  int64        `json:"memory_peak_bytes"`
}

type Sandbox struct {
	config   SandboxConfig
	mu       sync.RWMutex
	running  bool
	cancelFn context.CancelFunc
}

type CodeChange struct {
	FilePath   string `json:"file_path"`
	OldContent string `json:"old_content"`
	NewContent string `json:"new_content"`
	Diff       string `json:"diff"`
}

type DiffReport struct {
	Changes []CodeChange `json:"changes"`
	Summary DiffSummary  `json:"summary"`
}

type DiffSummary struct {
	FilesChanged  int      `json:"files_changed"`
	LinesAdded   int      `json:"lines_added"`
	LinesRemoved int      `json:"lines_removed"`
	Additions    []string `json:"additions,omitempty"`
	Deletions    []string `json:"deletions,omitempty"`
}

// NewSandbox creates a new sandbox instance
func NewSandbox(config SandboxConfig) (*Sandbox, error) {
	if config.WorkingDir == "" {
		config.WorkingDir = filepath.Join(os.TempDir(), "sandbox", randomID())
	}
	
	if err := os.MkdirAll(config.WorkingDir, 0755); err != nil {
		return nil, fmt.Errorf("failed to create working dir: %w", err)
	}
	
	return &Sandbox{
		config: config,
		running: false,
	}, nil
}

// Execute runs code within sandbox
func (s *Sandbox) Execute(ctx context.Context, code string, lang string) (*SandboxResult, error) {
	s.mu.Lock()
	if s.running {
		s.mu.Unlock()
		return nil, fmt.Errorf("sandbox already running")
	}
	s.running = true
	s.mu.Unlock()
	
	defer func() {
		s.mu.Lock()
		s.running = false
		s.mu.Unlock()
	}()
	
	ctx, cancel := context.WithTimeout(ctx, time.Duration(s.config.TimeoutSeconds)*time.Second)
	defer cancel()
	s.cancelFn = cancel
	
	switch strings.ToLower(lang) {
	case "python":
		return s.executePython(ctx, code)
	case "go":
		return s.executeGo(ctx, code)
	case "javascript", "nodejs":
		return s.executeNode(ctx, code)
	default:
		return nil, fmt.Errorf("unsupported language: %s", lang)
	}
}

// executePython executes Python code
func (s *Sandbox) executePython(ctx context.Context, code string) (*SandboxResult, error) {
	start := time.Now()
	
	scriptPath := filepath.Join(s.config.WorkingDir, "script.py")
	if err := os.WriteFile(scriptPath, []byte(code), 0644); err != nil {
		return nil, fmt.Errorf("failed to write script: %w", err)
	}
	
	cmd := execCommandContext(ctx, "python3", scriptPath)
	cmd.Dir = s.config.WorkingDir
	cmd.SysProcAttr = getSysProcAttr(s.config.MaxMemoryMB)
	
	var stdout, stderr bytes.Buffer
	cmd.Stdout = &stdout
	cmd.Stderr = &stderr
	
	err := cmd.Run()
	duration := time.Since(start).Seconds() * 1000
	
	result := &SandboxResult{
		ExitCode:    0,
		TestResults: []TestResult{},
		Output:      stdout.String(),
		Duration:    duration,
	}
	
	if err != nil {
		result.ExitCode = 1
		result.Error = stderr.String()
	}
	
	result.TestResults = s.parseTestOutput(stdout.String(), duration)
	
	return result, nil
}

// executeGo executes Go code
func (s *Sandbox) executeGo(ctx context.Context, code string) (*SandboxResult, error) {
	start := time.Now()
	
	mainPath := filepath.Join(s.config.WorkingDir, "main.go")
	if err := os.WriteFile(mainPath, []byte(code), 0644); err != nil {
		return nil, fmt.Errorf("failed to write main.go: %w", err)
	}
	
	compileCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
	defer cancel()
	
	compileCmd := execCommandContext(compileCtx, "go", "build", "-o", "program", mainPath)
	compileCmd.Dir = s.config.WorkingDir
	
	var compileErr bytes.Buffer
	compileCmd.Stderr = &compileErr
	
	if err := compileCmd.Run(); err != nil {
		return &SandboxResult{
			ExitCode: 1,
			Error:    compileErr.String(),
			Duration: time.Since(start).Seconds() * 1000,
		}, nil
	}
	
	cmd := execCommandContext(ctx, filepath.Join(s.config.WorkingDir, "program"))
	cmd.Dir = s.config.WorkingDir
	cmd.SysProcAttr = getSysProcAttr(s.config.MaxMemoryMB)
	
	var stdout, stderr bytes.Buffer
	cmd.Stdout = &stdout
	cmd.Stderr = &stderr
	
	duration := time.Since(start).Seconds() * 1000
	
	result := &SandboxResult{
		ExitCode:    0,
		TestResults: []TestResult{},
		Output:      stdout.String(),
		Duration:    duration,
	}
	
	if err := cmd.Run(); err != nil {
		result.ExitCode = 1
		result.Error = stderr.String()
	}
	
	result.TestResults = s.parseTestOutput(stdout.String(), duration)
	
	return result, nil
}

// executeNode executes JavaScript code
func (s *Sandbox) executeNode(ctx context.Context, code string) (*SandboxResult, error) {
	start := time.Now()
	
	scriptPath := filepath.Join(s.config.WorkingDir, "script.js")
	if err := os.WriteFile(scriptPath, []byte(code), 0644); err != nil {
		return nil, fmt.Errorf("failed to write script: %w", err)
	}
	
	cmd := execCommandContext(ctx, "node", scriptPath)
	cmd.Dir = s.config.WorkingDir
	cmd.SysProcAttr = getSysProcAttr(s.config.MaxMemoryMB)
	
	var stdout, stderr bytes.Buffer
	cmd.Stdout = &stdout
	cmd.Stderr = &stderr
	
	duration := time.Since(start).Seconds() * 1000
	
	result := &SandboxResult{
		ExitCode:    0,
		Output:      stdout.String(),
		Duration:    duration,
	}
	
	if err := cmd.Run(); err != nil {
		result.ExitCode = 1
		result.Error = stderr.String()
	}
	
	result.TestResults = s.parseTestOutput(stdout.String(), duration)
	
	return result, nil
}

// execCommandContext cross-platform command execution
func execCommandContext(ctx context.Context, name string, arg ...string) interface{} {
	return nil // Simplified; real implementation returns exec.Cmd
}

// getSysProcAttr get process attributes for resource limits
func getSysProcAttr(maxMemoryMB int64) interface{} {
	return nil
}

// parseTestOutput parse test output
func (s *Sandbox) parseTestOutput(output string, duration float64) []TestResult {
	results := []TestResult{}
	
	if strings.Contains(output, "{") {
		if idx := strings.Index(output, "{"); idx >= 0 {
			jsonStr := output[idx:]
			var parsed map[string]interface{}
			if err := json.Unmarshal([]byte(jsonStr), &parsed); err == nil {
				if tests, ok := parsed["tests"].([]interface{}); ok {
					for _, t := range tests {
						if testMap, ok := t.(map[string]interface{}); ok {
							results = append(results, TestResult{
								Name:     getString(testMap, "name"),
								Passed:   getBool(testMap, "passed"),
								Duration: getFloat64(testMap, "duration"),
							})
						}
					}
				}
			}
		}
	}
	
	if len(results) == 0 {
		results = append(results, TestResult{
			Name:     "default",
			Passed:   true,
			Duration: duration,
		})
	}
	
	return results
}

func getString(m map[string]interface{}, key string) string {
	if v, ok := m[key].(string); ok {
		return v
	}
	return ""
}

func getBool(m map[string]interface{}, key string) bool {
	if v, ok := m[key].(bool); ok {
		return v
	}
	return false
}

func getFloat64(m map[string]interface{}, key string) float64 {
	switch v := m[key].(type) {
	case float64:
		return v
	case int:
		return float64(v)
	}
	return 0
}

func randomID() string {
	return fmt.Sprintf("%d", time.Now().UnixNano())
}

// Stop stops the sandbox
func (s *Sandbox) Stop() error {
	s.mu.Lock()
	defer s.mu.Unlock()
	
	if s.cancelFn != nil {
		s.cancelFn()
	}
	
	s.running = false
	return nil
}

// Cleanup cleans up sandbox resources
func (s *Sandbox) Cleanup() error {
	return os.RemoveAll(s.config.WorkingDir)
}

// GenerateDiffReport generates code diff report
func GenerateDiffReport(oldCode, newCode string, filename string) *DiffReport {
	report := &DiffReport{
		Changes: []CodeChange{
			{
				FilePath:   filename,
				OldContent: oldCode,
				NewContent: newCode,
				Diff:       computeDiff(oldCode, newCode),
			},
		},
	}
	
	lines := strings.Split(report.Changes[0].Diff, "\n")
	for _, line := range lines {
		switch {
		case strings.HasPrefix(line, "+") && !strings.HasPrefix(line, "+++"):
			report.Summary.LinesAdded++
			report.Summary.Additions = append(report.Summary.Additions, line[1:])
		case strings.HasPrefix(line, "-") && !strings.HasPrefix(line, "---"):
			report.Summary.LinesRemoved++
			report.Summary.Deletions = append(report.Summary.Deletions, line[1:])
		}
	}
	report.Summary.FilesChanged = 1
	
	return report
}

// computeDiff simplified diff computation
func computeDiff(oldStr, newStr string) string {
	oldLines := strings.Split(oldStr, "\n")
	newLines := strings.Split(newStr, "\n")
	
	var diff []string
	diff = append(diff, "--- old")
	diff = append(diff, "+++ new")
	
	maxLen := max(len(oldLines), len(newLines))
	for i := 0; i < maxLen; i++ {
		var oldLine, newLine string
		if i < len(oldLines) {
			oldLine = oldLines[i]
		}
		if i < len(newLines) {
			newLine = newLines[i]
		}
		
		if oldLine == newLine {
			diff = append(diff, fmt.Sprintf(" %s", oldLine))
		} else {
			if oldLine != "" {
				diff = append(diff, fmt.Sprintf("-%s", oldLine))
			}
			if newLine != "" {
				diff = append(diff, fmt.Sprintf("+%s", newLine))
			}
		}
	}
	
	return strings.Join(diff, "\n")
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

// Main function example
func main() {
	fmt.Println("Sandbox Environment for Agent Iteration")
	fmt.Println("========================================")
	
	config := SandboxConfig{
		WorkingDir:     "",
		MaxMemoryMB:    512,
		MaxCPUPercent:  80,
		TimeoutSeconds: 60,
	}
	
	sb, err := NewSandbox(config)
	if err != nil {
		log.Fatalf("Failed to create sandbox: %v", err)
	}
	defer sb.Cleanup()
	
	testCode := `
package main

import "fmt"

func main() {
    fmt.Println("Hello from sandbox!")
}
`
	
	ctx := context.Background()
	result, err := sb.Execute(ctx, testCode, "go")
	if err != nil {
		log.Fatalf("Execution failed: %v", err)
	}
	
	fmt.Printf("Exit Code: %d\n", result.ExitCode)
	fmt.Printf("Output: %s\n", result.Output)
	fmt.Printf("Duration: %.2fms\n", result.Duration)
	fmt.Printf("Tests: %d/%d passed\n", 
		func() int {
			passed := 0
			for _, t := range result.TestResults {
				if t.Passed {
					passed++
				}
			}
			return passed
		}(), len(result.TestResults))
}

"""
AI Code Review System - Python Implementation
Claude-based automated code review and quality assessment
"""

import anthropic
import re
from dataclasses import dataclass
from typing import Optional
from enum import Enum


class IssueSeverity(Enum):
    CRITICAL = "critical"
    HIGH = "high"
    MEDIUM = "medium"
    LOW = "low"
    INFO = "info"


@dataclass
class CodeIssue:
    """Code issue definition"""
    line_number: Optional[int]
    severity: IssueSeverity
    category: str
    description: str
    suggestion: str
    ai_confidence: float


@dataclass
class CodeReviewResult:
    """Code review result"""
    file_path: str
    overall_score: float  # 0-10
    issues: list[CodeIssue]
    strengths: list[str]
    summary: str
    estimated_bugs_caught: float  # Compared to human engineers


class ClaudeCodeReviewer:
    """
    Claude-based Automated Code Reviewer
    
    Core Features:
    1. Static code analysis
    2. Security vulnerability detection
    3. Performance issue identification
    4. Code style evaluation
    5. Historical bug pattern matching
    """
    
    def __init__(
        self,
        api_key: str,
        model: str = "claude-sonnet-4-20250514"
    ):
        self.client = anthropic.Anthropic(api_key=api_key)
        self.model = model
        
        # Security check patterns
        self.security_patterns = {
            "sql_injection": re.compile(r'execute\(|exec\(|eval\('),
            "hardcoded_secret": re.compile(r'password\s*=\s*["\'][^"\']{8,}["\']'),
            "unsafe_deserialization": re.compile(r'pickle\.|yaml\.load\('),
            "path_traversal": re.compile(r'\.\./|\.\.\\'),
        }
        
    async def review_code(
        self,
        code: str,
        language: str = "python",
        file_path: str = "unknown.py"
    ) -> CodeReviewResult:
        """Review code"""
        
        # Step 1: Static analysis
        static_issues = self._static_analysis(code, language)
        
        # Step 2: Claude deep analysis
        claude_issues = await self._claude_analysis(code, language)
        
        # Step 3: Merge results
        all_issues = static_issues + claude_issues
        
        # Step 4: Calculate score
        overall_score = self._calculate_score(all_issues, code)
        
        # Step 5: Identify strengths
        strengths = self._identify_strengths(code, claude_issues)
        
        # Step 6: Generate summary
        summary = self._generate_summary(overall_score, all_issues)
        
        # Estimate how many human-missed bugs this catches
        estimated_bugs_caught = self._estimate_bug_catch_rate(
            overall_score, 
            len(all_issues)
        )
        
        return CodeReviewResult(
            file_path=file_path,
            overall_score=overall_score,
            issues=all_issues,
            strengths=strengths,
            summary=summary,
            estimated_bugs_caught=estimated_bugs_caught
        )
    
    def _static_analysis(
        self,
        code: str,
        language: str
    ) -> list[CodeIssue]:
        """Static code analysis"""
        issues = []
        
        # Security checks
        for name, pattern in self.security_patterns.items():
            matches = pattern.finditer(code)
            for match in matches:
                line_num = code[:match.start()].count('\n') + 1
                
                severity = IssueSeverity.CRITICAL
                if name == "hardcoded_secret":
                    severity = IssueSeverity.HIGH
                    
                issues.append(CodeIssue(
                    line_number=line_num,
                    severity=severity,
                    category="security",
                    description=f"Potential {name} vulnerability detected",
                    suggestion=self._get_security_suggestion(name),
                    ai_confidence=0.95
                ))
        
        # Code complexity checks (Python example)
        if language == "python":
            lines = code.split('\n')
            
            current_function = None
            function_lines = 0
            for i, line in enumerate(lines, 1):
                if re.match(r'^def\s+\w+', line):
                    if function_lines > 50 and current_function:
                        issues.append(CodeIssue(
                            line_number=i,
                            severity=IssueSeverity.MEDIUM,
                            category="maintainability",
                            description=f"Function '{current_function}' has {function_lines} lines",
                            suggestion="Consider breaking into smaller functions",
                            ai_confidence=0.8
                        ))
                    current_function = re.search(r'def\s+(\w+)', line).group(1)
                    function_lines = 0
                elif not line.strip().startswith('#'):
                    function_lines += 1
                    
        return issues
    
    def _get_security_suggestion(self, vulnerability: str) -> str:
        """Get security suggestions"""
        suggestions = {
            "sql_injection": "Use parameterized queries or ORM methods",
            "hardcoded_secret": "Use environment variables or secrets manager",
            "unsafe_deserialization": "Use json.loads() or yaml.safe_load() instead",
            "path_traversal": "Validate and sanitize user input for file paths",
        }
        return suggestions.get(vulnerability, "Review and fix security issue")
    
    async def _claude_analysis(
        self,
        code: str,
        language: str
    ) -> list[CodeIssue]:
        """Claude deep analysis"""
        
        prompt = f"""Analyze this {language} code and identify potential issues:

```{language}
{code}