# Create a virtual environment
python -m venv venv
source venv/bin/activate  # On Windows use: venv\Scripts\activate

# Install required libraries
pip install openai python-dotenv requests pydantic

# Initialize project
npm init -y

# Install dependencies
npm install openai dotenv axios zod

import os
import json
from typing import List, Optional
from dotenv import load_dotenv
from openai import OpenAI
from pydantic import BaseModel, Field

# Load environment variables
load_dotenv()

# 1. Define the Schema for Breach Data
class BreachReport(BaseModel):
    organization_name: str = Field(description="The name of the affected institution")
    impacted_count: int = Field(description="Estimated number of individuals affected")
    breach_type: str = Field(description="Type of breach (e.g., SQL Injection, Phishing)")
    severity_score: int = Field(description="Severity from 1-10")
    summary: str = Field(description="A brief summary of the incident")

class BreachMonitor:
    def __init__(self):
        self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

    def analyze_news_text(self, text: str) -> Optional[BreachReport]:
        """
        Uses GPT-4o to parse unstructured news text into a structured BreachReport object.
        """
        try:
            response = self.client.chat.completions.create(
                model="gpt-4o",
                messages=[
                    {"role": "system", "content": "You are a cybersecurity analyst. Extract breach details into JSON."},
                    {"role": "user", "content": f"Analyze this news: {text}"}
                ],
                response_format={"type": "json_object"}
            )
            
            # Parse the JSON response
            raw_data = json.loads(response.choices[0].message.content)
            return BreachReport(**raw_data)
            
        except Exception as e:
            print(f"Error during AI analysis: {e}")
            return None

# --- Execution Logic ---
if __name__ == "__main__":
    # Simulated news text based on the Lansing Community College event
    news_snippet = """
    Lansing Community College has confirmed a major data breach. 
    Security experts estimate that approximately 174,000 individuals 
    may have had their personal information compromised.
    """

    monitor = BreachMonitor()
    print("🔍 Analyzing breach data...")
    report = monitor.analyze_news_text(news_snippet)

    if report:
        print("\n✅ Breach Detected and Parsed:")
        print(f"Organization: {report.organization_name}")
        print(f"Impacted:     {report.impacted_count:,}")
        print(f"Severity:     {report.severity_score}/10")
        print(f"Summary:      {report.summary}")
    else:
        print("❌ Failed to parse breach information.")

import 'dotenv/config';
import OpenAI from 'openai';
import { z } from 'zod';

// 1. Define the Schema using Zod
const BreachSchema = z.object({
  organization_name: z.string(),
  impacted_count: z.number(),
  breach_type: z.string(),
  severity_score: z.number().min(1).max(10),
  summary: z.string(),
});

type BreachReport = z.infer<typeof BreachSchema>;

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

async function analyzeBreach(newsText: string): Promise<BreachReport | null> {
  try {
    const response = await openai.chat.completions.create({
      model: "gpt-4o",
      messages: [
        { 
          role: "system", 
          content: "You are a security intelligence bot. Return ONLY valid JSON matching the requested schema." 
        },
        { role: "user", content: newsText }
      ],
      response_format: { type: "json_object" },
    });

    const content = response.choices[0].message.content;
    if (!content) throw new Error("Empty response from AI");

    // 2. Validate the AI response against our schema
    const parsed = JSON.parse(content);
    return BreachSchema.parse(parsed);

  } catch (error) {
    console.error("🚨 Error processing breach news:", error);
    return null;
  }
}

// --- Execution Logic ---
const newsSnippet = "Lansing Community College reports a breach affecting 174,000 users.";

analyzeBreach(newsSnippet).then((report) => {
  if (report) {
    console.log("✅ Structured Data Received:");
    console.table(report);
  } else {
    console.log("❌ Analysis failed.");
  }
});

# OpenAI Configuration
OPENAI_API_KEY=sk-proj-xxxxxxxxxxxxxxxxxxxxxxxxxxxx

# News Source Configuration (Example)
NEWS_API_KEY=your_news_api_key_here

# Application Settings
LOG_LEVEL=info
ENVIRONMENT=production

import time

def robust_ai_call(func, retries=3, delay=2):
    for i in range(retries):
        try:
            return func()
        except Exception as e:
            if i == retries - 1: raise e
            print(f"Attempt {i+1} failed. Retrying in {delay}s...")
            time.sleep(delay)

def should_trigger_alert(report: BreachReport) -> bool:
    # Only alert if more than 10,000 people are affected OR severity > 7
    return report.impacted_count > 10000 or report.severity_score >= 7