# schema_validator.py
import json
import jsonschema
from anthropic import Anthropic

client = Anthropic()

def generate_schema_from_examples(examples: list[dict]) -> dict:
    """Use Claude to infer a strict JSON Schema from example payloads."""
    examples_json = json.dumps(examples[:5], indent=2)

    response = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=2000,
        messages=[{
            "role": "user",
            "content": f"""Generate a strict JSON Schema (draft-07) from these examples.
Rules:
- Mark fields present in all examples as required
- Use specific types (no 'any')
- Add format hints (email, date-time, uri) where obvious
- Use additionalProperties: false for all objects
- Add minimum/maximum for numeric fields if pattern is clear

Return only valid JSON, no explanation.

Examples:
{examples_json}"""
        }]
    )

    schema_text = response.content[0].text.strip()
    # Strip markdown code blocks if present
    if schema_text.startswith("```"):
 schema_text = "\n".join(schema_text.split("\n")[1:-1])

 return json.loads(schema_text)


def validate_payload(payload: dict, schema: dict) -> dict:
 """Validate a payload and return human-readable error summary."""
 validator = jsonschema.Draft7Validator(schema)
 errors = list(validator.iter_errors(payload))

 if not errors:
 return {"valid": True, "errors": []}

 error_list = []
 for error in errors:
 path = " -> ".join(str(p) for p in error.absolute_path) or "root"
 error_list.append({
 "path": path,
 "message": error.message,
 "schema_path": " -> ".join(str(p) for p in error.absolute_schema_path)
 })

 return {"valid": False, "errors": error_list}


# Usage example
if __name__ == "__main__":
 training_examples = [
 {
 "user_id": "usr_abc123",
 "email": "alice@example.com",
 "created_at": "2026-01-01T00:00:00Z",
 "plan": "pro",
 "seats": 5
 },
 {
 "user_id": "usr_def456",
 "email": "bob@example.com",
 "created_at": "2026-02-15T12:30:00Z",
 "plan": "free",
 "seats": 1
 }
 ]

 schema = generate_schema_from_examples(training_examples)
 print("Generated schema:")
 print(json.dumps(schema, indent=2))

 # Test with a bad payload
 bad_payload = {
 "user_id": "usr_xyz",
 "email": "not-an-email",
 "created_at": "2026-03-22", # wrong format
 "plan": "enterprise",
 "seats": -1 # negative seats
 }

 result = validate_payload(bad_payload, schema)
 if not result["valid"]:
 print("\nValidation errors:")
 for err in result["errors"]:
 print(f" [{err['path']}] {err['message']}")

# migration_analyzer.py
from anthropic import Anthropic
import re

client = Anthropic()

MIGRATION_PROMPT = """Analyze this SQL migration for production safety.

Check for:
1. Table locks: ALTER TABLE on large tables, adding NOT NULL without DEFAULT
2. Index operations: CREATE INDEX without CONCURRENTLY on PostgreSQL
3. Data loss risk: DROP COLUMN, DROP TABLE, TRUNCATE
4. Breaking changes: column rename (apps may still reference old name)
5. Performance: missing index on new foreign keys

For each issue found, output:
RISK: [HIGH | MEDIUM | LOW]
LINE: [line number or N/A]
ISSUE: [description]
FIX: [recommended fix]

Migration:
"""

def analyze_migration(migration_sql: str) -> list[dict]:
 response = client.messages.create(
 model="claude-opus-4-6",
 max_tokens=1500,
 messages=[{
 "role": "user",
 "content": MIGRATION_PROMPT + migration_sql
 }]
 )

 text = response.content[0].text
 issues = []

 # Parse structured output
 blocks = re.split(r'\n(?=RISK:)', text.strip())
 for block in blocks:
 if "RISK:" not in block:
 continue
 issue = {}
 for line in block.split("\n"):
 for key in ["RISK", "LINE", "ISSUE", "FIX"]:
 if line.startswith(f"{key}:"):
 issue[key.lower()] = line[len(key)+1:].strip()
 if issue:
 issues.append(issue)

 return issues


# Test migration
test_migration = """
ALTER TABLE users ADD COLUMN last_login_ip VARCHAR(45) NOT NULL;
CREATE INDEX idx_users_email ON users (email);
ALTER TABLE orders DROP COLUMN legacy_status;
ALTER TABLE products ADD COLUMN category_id INT REFERENCES categories(id);
"""

issues = analyze_migration(test_migration)
for issue in issues:
 print(f"[{issue.get('risk', '?')}] {issue.get('issue', '')}")
 print(f" Fix: {issue.get('fix', '')}\n")