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

# Install dependencies
pip install openai newsapi-python python-dotenv requests

# Initialize project
npm init -y

# Install dependencies
npm install openai axios dotenv

import os
from newsapi import NewsApiClient
from openai import OpenAI
from dotenv import load_dotenv

# Load environment variables from.env file
load_dotenv()

class ThreatIntelligenceEngine:
    def __init__(self):
        # Initialize clients
        self.newsapi = NewsApiClient(api_key=os.getenv("NEWS_API_KEY"))
        self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

    def fetch_critical_infrastructure_news(self, query: str):
        """Fetches recent news articles related to the query."""
        try:
            articles = self.newsapi.get_everything(
                q=query,
                language='en',
                sort_by='publishedAt',
                page_size=5
            )
            return articles.get('articles', [])
        except Exception as e:
            print(f"Error fetching news: {e}")
            return []

    def analyze_threat_severity(self, article_content: str) -> dict:
        """Uses AI to classify the severity of the reported cyberattack."""
        prompt = f"""
        Analyze the following news snippet regarding critical infrastructure.
        Determine the 'Severity Level' (Low, Medium, High, Critical) and 
        extract the 'Target Sector' (e.g., Water, Power, Healthcare).
        
        Text: {article_content}
        
        Return ONLY a JSON object:
        {{"severity": "string", "target": "string", "reasoning": "string"}}
        """

        try:
            response = self.client.chat.completions.create(
                model="gpt-3.5-turbo-0125", # or gpt-4
                messages=[{"role": "user", "content": prompt}],
                response_format={ "type": "json_object" }
            )
            return response.choices[0].message.content
        except Exception as e:
            return f"AI Analysis Error: {str(e)}"

    def run_pipeline(self, query: str):
        print(f"--- Starting Intelligence Scan for: {query} ---")
        articles = self.fetch_critical_infrastructure_news(query)
        
        for art in articles:
            print(f"\n[NEWS]: {art['title']}")
            analysis = self.analyze_threat_severity(art['description'])
            print(f"[AI ANALYSIS]: {analysis}")

if __name__ == "__main__":
    engine = ThreatIntelligenceEngine()
    # Target specifically the water sector attacks mentioned in the report
    engine.run_pipeline("water sector cyberattack states")

import 'dotenv/config';
import axios from 'axios';
import OpenAI from 'openai';

class ThreatMonitor {
    constructor() {
        this.openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
        this.newsApiKey = process.env.NEWS_API_KEY;
    }

    async fetchNews(query) {
        try {
            const response = await axios.get(`https://newsapi.org/v2/everything?q=${query}&language=en&sortBy=publishedAt&apiKey=${this.newsApiKey}`);
            return response.data.articles;
        } catch (error) {
            console.error("Error fetching news:", error.message);
            return [];
        }
    }

    async analyzeArticle(text) {
        try {
            const response = await this.openai.chat.completions.create({
                model: "gpt-3.5-turbo",
                messages: [
                    { 
                        role: "system", 
                        content: "You are a cybersecurity analyst. Respond only in JSON." 
                    },
                    { 
                        role: "user", 
                        content: `Analyze this threat: ${text}. Return JSON: {severity: 'Low|Medium|High|Critical', sector: 'tring'}` 
                    }
                ],
                response_format: { type: "json_object" }
            });
            return JSON.parse(response.choices[0].message.content);
        } catch (error) {
            return { error: "Analysis failed", details: error.message };
        }
    }

    async startMonitoring(query) {
        console.log(`Monitoring: ${query}...`);
        const articles = await this.fetchNews(query);

        for (const article of articles.slice(0, 3)) {
            const analysis = await this.analyzeArticle(article.description || article.title);
            console.log('-----------------------------------');
            console.log(`TITLE: ${article.title}`);
            console.log(`ANALYSIS:`, analysis);
        }
    }
}

const monitor = new ThreatMonitor();
monitor.startMonitoring("water sector cyberattack");

# AI Provider
OPENAI_API_KEY=sk-your-actual-openai-key-here

# News Provider
NEWS_API_KEY=your-news-api-key-here

# System Settings
ENVIRONMENT=development
LOG_LEVEL=info