# chaos_planner.py
from anthropic import Anthropic

client = Anthropic()

ARCHITECTURE_DESCRIPTION = """
E-commerce platform:
- Frontend: Next.js on Vercel
- API gateway: Kong on Kubernetes (3 replicas)
- Services:
  - order-service (3 pods, PostgreSQL primary + 1 replica)
  - inventory-service (2 pods, Redis cache + PostgreSQL)
  - payment-service (2 pods, Stripe API dependency)
  - notification-service (1 pod, SQS consumer)
- Infrastructure: AWS EKS, RDS Multi-AZ, ElastiCache cluster mode
- Service mesh: Istio with circuit breakers configured
"""

def generate_experiment_backlog(architecture: str) -> str:
    response = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=2500,
        messages=[{
            "role": "user",
            "content": f"""You are a chaos engineering expert.
Given this architecture, generate a prioritized chaos experiment backlog.

For each experiment include:
- NAME: Short identifier
- HYPOTHESIS: What we expect to happen when resilience is working
- FAILURE_MODE: Exact failure to inject
- BLAST_RADIUS: What could break beyond the target
- PRIORITY: [P1 / P2 / P3] based on business impact
- TOOLING: Which tool to use (Litmus, Chaos Mesh, AWS FIS, manual)

Architecture:
{architecture}

Generate 10 experiments covering: network latency, pod failures,
database failover, dependency timeouts, resource exhaustion, and AZ failure."""
        }]
    )
    return response.content[0].text

backlog = generate_experiment_backlog(ARCHITECTURE_DESCRIPTION)
print(backlog)

# chaos_config_generator.py
from anthropic import Anthropic
import yaml

client = Anthropic()

def generate_litmus_experiment(experiment_spec: dict) -> str:
    """Generate a LitmusChaos ChaosEngine YAML from a spec dict."""
    response = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=2000,
        messages=[{
            "role": "user",
            "content": f"""Generate a valid LitmusChaos ChaosEngine YAML for this experiment.

Use litmus experiments from hub.litmuschaos.io.
Include all required fields. Add comments explaining key parameters.

Experiment spec:
{yaml.dump(experiment_spec, default_flow_style=False)}

Return only the YAML, no explanation."""
        }]
    )
    return response.content[0].text

# Example experiment
order_pod_kill = {
    "name": "order-service-pod-kill",
    "target_namespace": "production",
    "target_app": "order-service",
    "app_label": "app=order-service",
    "failure": "kill 1 pod",
    "duration_seconds": 60,
    "monitoring": {
        "success_criteria": "order_success_rate > 99%",
        "abort_if": "error_rate > 5%"
    }
}

yaml_config = generate_litmus_experiment(order_pod_kill)
print(yaml_config)

def analyze_blast_radius(
    experiment_yaml: str,
    architecture_description: str
) -> dict:
    response = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=1500,
        messages=[{
            "role": "user",
            "content": f"""Analyze the blast radius of this chaos experiment.

Architecture context:
{architecture_description}

Experiment config:
{experiment_yaml}

Provide:
1. DIRECT_IMPACT: What is directly affected
2. CASCADING_RISKS: What else could fail as a consequence
3. DATA_RISK: Any risk of data loss or corruption
4. ROLLBACK_PLAN: How to stop and recover if things go wrong
5. SAFE_TO_RUN: [YES / REQUIRES_APPROVAL / NO] with justification
6. PREREQUISITES: What must be true before running (monitoring, low-traffic window, etc.)"""
        }]
    )

    text = response.content[0].text
    return {"analysis": text, "raw": experiment_yaml}

analysis = analyze_blast_radius(yaml_config, ARCHITECTURE_DESCRIPTION)
print(analysis["analysis"])

def generate_istio_fault_injection(
    service_name: str,
    fault_type: str,  # "delay" or "abort"
    target_host: str,
    fault_value: str,  # "2000ms" or "503"
    percentage: int = 50
) -> str:
    """Generate Istio VirtualService YAML for fault injection."""
    response = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=800,
        messages=[{
            "role": "user",
            "content": f"""Generate an Istio VirtualService YAML that injects a
{fault_type} fault of {fault_value} for {percentage}% of requests from
{service_name} to {target_host}.

Include the original routing rule so non-faulted traffic is unaffected.
Return only the YAML."""
        }]
    )
    return response.content[0].text

# Example: Add 2s delay to 30% of payment service → Stripe calls
istio_config = generate_istio_fault_injection(
    service_name="payment-service",
    fault_type="delay",
    target_host="api.stripe.com",
    fault_value="2000ms",
    percentage=30
)
print(istio_config)

def generate_fis_template(experiment_spec: dict) -> str:
    """Generate an AWS FIS experiment template JSON."""
    response = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=1500,
        messages=[{
            "role": "user",
            "content": f"""Generate an AWS FIS experiment template JSON for this experiment.

Include:
- Correct action IDs (aws:rds:failover-db-cluster, aws:ec2:stop-instances, etc.)
- Stop conditions using CloudWatch alarms
- IAM role reference
- Target resource filters

Experiment:
{yaml.dump(experiment_spec, default_flow_style=False)}

Return only valid FIS template JSON."""
        }]
    )
    return response.content[0].text

rds_failover = {
    "name": "rds-failover-test",
    "description": "Trigger RDS Multi-AZ failover and measure recovery time",
    "target": "production RDS cluster",
    "db_cluster_id": "my-prod-cluster",
    "stop_condition_alarm": "HighErrorRate5xx",
    "expected_recovery_time_seconds": 30
}

fis_template = generate_fis_template(rds_failover)
print(fis_template)