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

# Install necessary libraries
pip install openai python-dotenv pydantic loguru

# Initialize project
npm init -y

# Install dependencies
npm install openai dotenv zod

import os
import asyncio
from typing import Dict, Any
from pydantic import BaseModel, Field
from openai import OpenAI
from dotenv import load_dotenv
from loguru import logger

# Load environment variables
load_dotenv()

# Define the schema for structured AI output
class BreachAnalysis(BaseModel):
    is_sensitive: bool = Field(description="True if the data contains PII or corporate credentials")
    risk_level: str = Field(description="Low, Medium, or High")
    detected_entities: list[str] = Field(description="List of detected entity types (e.1. Email, SSN, EmployeeID)")
    summary: str = Field(description="Brief explanation of why this is a risk")

class BreachMonitor:
    def __init__(self):
        self.client = OpenAI(api_key=osthought_key := os.getenv("OPENAI_API_KEY"))
        # Configure logging for production visibility
        logger.add("breach_monitor.log", rotation="500 MB", level="INFO")

    async def analyze_leak_snippet(self, raw_data: str) -> Dict[str, Any]:
        """
        Uses GPT-4o to classify the severity of a data snippet.
        """
        try:
            logger.info("Analyzing data snippet...")
            
            # Structured output ensures the AI returns valid JSON matching our Pydantic model
            completion = self.client.beta.chat.completions.parse(
                model="gpt-4o-2024-08-06",
                messages=[
                    {"role": "system", "content": "You are a Cyber Security Analyst specializing in Data Loss Prevention (DLP)."},
                    {"role": "user", "content": f"Analyze this leaked data fragment for corporate risk: {raw_data}"}
                ],
                response_format=BreachAnalysis,
            )

            analysis = completion.choices[0].message.parsed
            return analysis.model_dump()

        except Exception as e:
            logger.error(f"Failed to analyze snippet: {str(e)}")
            return {"error": str(e), "is_sensitive": False}

async def main():
    monitor = BreachMonitor()
    
    # Simulated snippet resembling a PeopleSoft database dump
    leaked_snippet = "ID: 88291 | Name: Tanaka, Hiroshi | Dept: Manufacturing | Email: h.tanaka@nissan-corp.jp | Role: Senior Engineer"
    
    result = await monitor.analyze_leak_snippet(leaked_snippet)
    
    print("\n--- Breach Analysis Report ---")
    print(f"Sensitive: {result['is_sensitive']}")
    print(f"Risk Level: {result['risk_level']}")
    print(f"Entities: {', '.join(result['detected_entities'])}")
    print(f"Summary: {result['summary']}")

if __name__ de-main():
    if __name__ == "__main__":
        asyncio.run(main())

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

// Define the schema for the AI response using Zod
const BreachSchema = z.object({
  is_sensitive: z.boolean(),
  risk_level: z.enum(['Low', 'Medium', 'High']),
  detected_entities: z.array(z.string()),
  summary: z.string(),
});

type BreachAnalysis = z.infer<typeof BreachSchema>;

class BreachDetectionService {
  private openai: OpenAI;

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

  async analyzeSnippet(text: string): Promise<BreachAnalysis | null> {
    try {
      const response = await this.openai.chat.completions.create({
        model: "gpt-4o-2024-08-06",
        messages: [
          { role: "system", content: "You are a security automation engine. Classify data leaks." },
          { role: "user", content: `Analyze this: ${text}` }
        ],
        response_format: { type: "json_object" },
      });

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

      // Validate the JSON structure
      const parsed = JSON.parse(content);
      return BreachSchema.parse(parsed);
    } catch (error) {
      console.error("🚨 [Detection Error]:", error instanceof Error? error.message : error);
      return null;
    }
  }
}

// Execution Logic
async function runDemo() {
  const detector = new BreachDetectionService();
  const rawData = "User: j.doe@nissan-example.com, Pass: Oracle123!, Access_Level: Admin";

  console.log("🔍 Scanning incoming data stream...");
  const result = await detector.analyzeSnippet(rawData);

  if (result && result.is_sensitive) {
    console.log("⚠️ ALERT: High Risk Data Detected!");
    console.log(`Reason: ${result.summary}`);
    console.log(`Entities: ${result.detected_entities.join(', ')}`);
  } else {
    console.log("✅ Data appears safe.");
  }
}

runDemo();

#.env file
OPENAI_API_KEY=sk-proj-your-secret-key-here
LOG_LEVEL=INFO
ENVIRONMENT=production
# Threshold for triggering automated Slack/PagerDuty alerts
RISK_THRESHOLD=high 

import re

def mask_pii(text: str) -> str:
    # Simple regex to mask emails before sending to OpenAI
    return re.sub(r'\S+@\S+', '[EMAIL_REDACTED]', text)