# Install Trivy
curl -sfL https://raw.githubusercontent.com/aquasecurity/trivy/main/contrib/install.sh | sh -s -- -b /usr/local/bin

# Scan running containers
trivy image --severity HIGH,CRITICAL your-image:tag

# Scan host packages
trivy fs --security-checks vuln /

#!/bin/bash
# Runs daily at 2 AM, scans all running containers
REPORT_DATE=$(date +%Y-%m-%d)
LOG_FILE="/var/log/security/container-scan-${REPORT_DATE}.log"

echo "=== Container Vuln Scan Started: $(date) ===" >> "$LOG_FILE"

docker ps --format '{{.Names}}' | while read -r container; do
    echo "Scanning container: $container" >> "$LOG_FILE"
    trivy image \
        --severity HIGH,CRITICAL \
        --format json \
        "$(docker inspect --format='{{.Config.Image}}' "$container")" 2>/dev/null \
        | jq '.Results[]?.Vulnerabilities // [] | length' >> "$LOG_FILE"
done

echo "=== Scan Complete: $(date) ===" >> "$LOG_FILE"

0 2 * * * /opt/security/scan-containers.sh

#!/bin/bash
# /opt/security/scan-system.sh
# Weekly Sunday system-level vulnerability scan

apt list --upgradable 2>/dev/null | grep -v "^Listing" > /tmp/upgradable-packages.txt

# Scan OS packages with Trivy
trivy fs --security-checks vuln \
    --scanners vuln \
    --severity CRITICAL,HIGH \
    / 2>/dev/null | jq -r '.Results[]?.Vulnerabilities[]? | 
    "\(.Severity) [\(.VulnerabilityID)] \(.Title)"' > /tmp/critical-vulns.txt

# Alert if critical vulnerabilities found
if [ -s /tmp/critical-vulns.txt ]; then
    curl -X POST "https://api.telegram.org/bot${TG_BOT_TOKEN}/sendMessage" \
        -d "chat_id=${TG_CHAT_ID}" \
        -d "text=*⚠️ Critical Vulnerabilities Found!*$(cat /tmp/critical-vulns.txt | head -5)" \
        -d "parse_mode=Markdown"
fi

# Create a dedicated security analysis model
cat > /etc/ollama/modelfiles/vuln-analyzer << 'EOF'
FROM qwen2.5:7b

SYSTEM """You are a professional security analyst. Your responsibilities:
1. Analyze CVE vulnerability details and assess actual risk level
2. Determine if the vulnerability affects the current system environment
3. Provide specific remediation recommendations with priority ordering
4. Identify correlations between vulnerabilities (e.g., multiple low-severity vulns combining into a high-severity scenario)

Output format as JSON:
{
  "cve_id": "CVE-2024-XXXX",
  "actual_risk": "critical|high|medium|low",
  "impact_analysis": "Actual impact in current environment",
  "fix_priority": 1,
  "fix_steps": ["Specific remediation steps"],
  "workaround": "Temporary mitigation (if any)",
  "related_vulns": ["Related vulnerability list"]
}"""
EOF

ollama create vuln-analyzer -f /etc/ollama/modelfiles/vuln-analyzer

#!/usr/bin/env python3
"""
AI Vulnerability Analysis Engine
Automatically analyzes Trivy scan results and generates actionable remediation plans
"""

import json
import subprocess
import logging
from datetime import datetime
from pathlib import Path
from typing import List, Dict

try:
    import ollama
except ImportError:
    print("Please install ollama Python library: pip install ollama")
    exit(1)

logging.basicConfig(level=logging.INFO, format='%(asctime)s [%(levelname)s] %(message)s')
logger = logging.getLogger("vuln-analyzer")


class VulnAnalyzer:
    """Vulnerability analyzer"""
    
    def __init__(self):
        self.model = "vuln-analyzer"
    
    def scan_trivy(self, target: str = "/") -> List[Dict]:
        """Run Trivy scan and return structured results"""
        try:
            result = subprocess.run(
                ["trivy", "fs", "--security-checks", "vuln",
                 "--severity", "HIGH,CRITICAL",
                 "--format", "json", target],
                capture_output=True, text=True, timeout=300
            )
            data = json.loads(result.stdout)
            
            vulnerabilities = []
            for item in data.get("Results", []):
                for vuln in item.get("Vulnerabilities", []):
                    vulnerabilities.append({
                        "vulnerability_id": vuln["VulnerabilityID"],
                        "package": vuln.get("PkgName", ""),
                        "installed_version": vuln.get("InstalledVersion", ""),
                        "fixed_version": vuln.get("FixedVersion", "N/A"),
                        "severity": vuln["Severity"],
                        "title": vuln["Title"],
                        "description": vuln.get("Description", ""),
                        "cvss_score": vuln.get("CVSS", {}).get("nvd", {}).get("v3", {}).get("vectorString", ""),
                        "references": vuln.get("References", []),
                    })
            
            return vulnerabilities
        
        except Exception as e:
            logger.error(f"Scan failed: {e}")
            return []
    
    def analyze_vuln(self, vuln: Dict) -> Dict:
        """Analyze a single vulnerability using LLM"""
        prompt = f"""Analyze the following security vulnerability:

CVE ID: {vuln['vulnerability_id']}
Title: {vuln['title']}
Severity: {vuln['severity']}
Installed Version: {vuln['installed_version']}
Fixed Version: {vuln['fixed_version']}
Description: {vuln['description']}
CVSS: {vuln['cvss_score']}

Assess the actual impact in this VPS environment and provide remediation advice."""
        
        try:
            response = ollama.generate(
                model=self.model,
                prompt=prompt,
                options={"temperature": 0.2, "num_predict": 500}
            )
            
            output = response.get("response", "")
            # Extract JSON portion
            json_start = output.find("{")
            json_end = output.rfind("}") + 1
            if json_start >= 0 and json_end > json_start:
                return json.loads(output[json_start:json_end])
            else:
                return {"error": "Failed to parse LLM response"}
        
        except Exception as e:
            logger.error(f"Analysis failed: {e}")
            return {"error": str(e)}
    
    def prioritize_fixes(self, analyses: List[Dict]) -> List[Dict]:
        """Prioritize vulnerability fixes"""
        priority_map = {"CRITICAL": 1, "HIGH": 2, "MEDIUM": 3, "LOW": 4}
        
        sorted_analyses = sorted(
            analyses,
            key=lambda x: priority_map.get(x.get("severity", "LOW"), 4)
        )
        
        for i, analysis in enumerate(sorted_analyses):
            analysis["fix_priority"] = i + 1
        
        return sorted_analyses
    
    def generate_report(self, vulnerabilities: List[Dict]) -> str:
        """Generate security report"""
        report = f"""
# 🔒 VPS Security Analysis Report
**Generated**: {datetime.now().strftime('%Y-%m-%d %H:%M')}

## Overview
- Total vulnerabilities found: {len(vulnerabilities)}
- Critical: {sum(1 for v in vulnerabilities if v['severity'] == 'CRITICAL')}
- High: {sum(1 for v in vulnerabilities if v['severity'] == 'HIGH')}
- Medium: {sum(1 for v in vulnerabilities if v['severity'] == 'MEDIUM')}
- Low: {sum(1 for v in vulnerabilities if v['severity'] == 'LOW')}

## Details
"""
        for vuln in vulnerabilities[:10]:
            report += f"""
### [{vuln['severity']}] {vuln['vulnerability_id']}
- **Package**: {vuln['package']}
- **Current Version**: {vuln['installed_version']}
- **Fixed Version**: {vuln['fixed_version']}
- **Description**: {vuln['title']}
"""
        
        report += """
## Recommended Actions
1. Immediately fix all CRITICAL severity vulnerabilities
2. Fix HIGH severity vulnerabilities within 24 hours
3. Address MEDIUM severity vulnerabilities this week
4. Plan LOW severity vulnerability remediation
"""
        
        return report


if __name__ == "__main__":
    analyzer = VulnAnalyzer()
    
    # Scan
    vulns = analyzer.scan_trivy("/")
    logger.info(f"Found {len(vulns)} vulnerabilities")
    
    # Analyze top 5 critical/high vulnerabilities
    critical_vulns = [v for v in vulns if v["severity"] in ["CRITICAL", "HIGH"]]
    for vuln in critical_vulns[:5]:
        analysis = analyzer.analyze_vuln(vuln)
        logger.info(f"Analysis for {vuln['vulnerability_id']}: {analysis}")
    
    # Generate report
    report = analyzer.generate_report(critical_vulns)
    print(report)

# Install CrowdSec
curl -s https://raw.githubusercontent.com/crowdsecurity/crowdsec/main/scripts/install_crowdsec.sh | bash

# Install Nginx parser
cscli parsers install crowdsecurity/nginx

# Install Linux parser
cscli parsers install crowdsecurity/linux

# Install blocking action (iptables)
cscli actions install crowdsecurity/whitelists
cscli actions install crowdsecurity/iptables

# Start and enable
systemctl enable --now crowdsec

#!/usr/bin/env python3
"""
AI-Enhanced Threat Intelligence Analysis
Analyzes IPs blocked by CrowdSec to determine if they're false positives
"""

import json
import requests
import logging
from datetime import datetime

try:
    import ollama
except ImportError:
    print("Please install ollama: pip install ollama")
    exit(1)

logger = logging.getLogger("threat-analyzer")


class ThreatAnalyzer:
    """Threat intelligence analyzer"""
    
    def __init__(self):
        self.crowdsec_api = "http://localhost:8080"
    
    def get_bans(self, limit: int = 50) -> list:
        """Get recent ban records"""
        try:
            response = requests.get(
                f"{self.crowdsec_api}/v1/decisions/signal",
                headers={"X-Api-Key": "your-api-key"},
                params={"limit": limit}
            )
            return response.json()
        except Exception as e:
            logger.error(f"Failed to get ban records: {e}")
            return []
    
    def analyze_ip_threat(self, ban_entry: dict) -> dict:
        """Analyze threat level of a single ban event"""
        scenario = ban_entry.get("Scenario", "")
        source_ip = ban_entry.get("Value", "")
        country = ban_entry.get("Country", "unknown")
        
        prompt = f"""Analyze the following security event:

- Source IP: {source_ip}
- Country: {country}
- Triggered Scenario: {scenario}
- Ban Time: {datetime.fromtimestamp(ban_entry.get("Timestamp", 0)).isoformat()}

Determine:
1. Is this a real attack or false positive?
2. Threat level (critical/high/medium/low)
3. Recommended ban duration
4. Whether manual review is needed"""
        
        try:
            response = ollama.generate(
                model="vuln-analyzer",
                prompt=prompt,
                options={"temperature": 0.1}
            )
            
            output = response.get("response", "")
            json_start = output.find("{")
            json_end = output.rfind("}") + 1
            if json_start >= 0 and json_end > json_start:
                return json.loads(output[json_start:json_end])
            
            return {"assessment": "manual_review_needed"}
        
        except Exception as e:
            return {"error": str(e)}
    
    def auto_unban_false_positive(self, ip: str):
        """Auto-unban false positive IP"""
        try:
            import subprocess
            subprocess.run(["cscli", "bouncer", "delete", ip], check=True)
            logger.info(f"Auto-unbanned false positive IP: {ip}")
        except Exception as e:
            logger.error(f"Unban failed: {e}")


# Run daily threat analysis
if __name__ == "__main__":
    analyzer = ThreatAnalyzer()
    bans = analyzer.get_bans(limit=100)
    
    for ban in bans[:20]:
        analysis = analyzer.analyze_ip_threat(ban)
        logger.info(f"Analysis result: {analysis}")

name: LocalCustomDetection
description: "Custom VPS security detection rules"

filters:
  - Alert.Type == "ban" && Alert.GetSource().Country == "CN"

whens:
  - event.After("10m")

process:
  - name: ai_threat_intel
    enabled: true
    priority: 100
    args:
      model: "vuln-analyzer"
      action: "analyze"

#!/usr/bin/env python3
"""
Intelligent Patch Manager
Evaluates patch risk and generates safe update plans
"""

import subprocess
import json
import logging
from datetime import datetime

try:
    import ollama
except ImportError:
    exit(1)

logger = logging.getLogger("patch-manager")


class PatchManager:
    """Patch manager"""
    
    def __init__(self):
        self.model = "vuln-analyzer"
    
    def get_upgradable_packages(self) -> list:
        """Get list of upgradable packages"""
        result = subprocess.run(
            ["apt", "list", "--upgradable"],
            capture_output=True, text=True
        )
        packages = []
        for line in result.stdout.splitlines():
            if "upgradable" in line:
                pkg_name = line.split("/")[0].split(":")[-1]
                current_ver = line.split(" ")[-1]
                packages.append({"name": pkg_name, "current_version": current_ver})
        return packages
    
    def assess_patch_risk(self, package: dict) -> dict:
        """Assess patch risk"""
        prompt = f"""Assess the risk of upgrading the following package:

Package: {package['name']}
Current Version: {package['current_version']}
Server Environment: Ubuntu/Debian VPS, Docker containerized apps

Analyze:
1. Will upgrading this package cause service interruption?
2. Are there known compatibility issues?
3. Recommended upgrade strategy (immediate/planned/skip)
4. Pre-upgrade backup suggestions"""
        
        try:
            response = ollama.generate(
                model=self.model,
                prompt=prompt,
                options={"temperature": 0.1, "num_predict": 300}
            )
            
            output = response.get("response", "")
            json_start = output.find("{")
            json_end = output.rfind("}") + 1
            if json_start >= 0 and json_end > json_start:
                return json.loads(output[json_start:json_end])
            
            return {"risk_level": "unknown"}
        
        except Exception as e:
            return {"error": str(e)}
    
    def safe_update(self, packages: list, dry_run: bool = True):
        """Execute safe updates"""
        if dry_run:
            logger.info("Dry run mode - not executing actual updates")
            cmd = ["apt", "upgrade", "-s"]
        else:
            logger.info("Executing actual updates")
            cmd = ["sudo", "apt", "upgrade", "-y"]
        
        result = subprocess.run(cmd, capture_output=True, text=True)
        logger.info(result.stdout)
        if result.stderr:
            logger.warning(result.stderr)
        
        return result.returncode == 0


if __name__ == "__main__":
    manager = PatchManager()
    
    # Get upgradable packages
    packages = manager.get_upgradable_packages()
    logger.info(f"Found {len(packages)} upgradable packages")
    
    # Assess risk for each package
    risk_assessments = []
    for pkg in packages[:10]:  # Only assess first 10
        assessment = manager.assess_patch_risk(pkg)
        risk_assessments.append({"package": pkg, "assessment": assessment})
    
    # Generate update plan
    critical_updates = [a for a in risk_assessments 
                       if a["assessment"].get("recommended_action") == "immediate"]
    
    if critical_updates:
        logger.info(f"Need immediate updates: {len(critical_updates)} packages")
        manager.safe_update([p["package"]["name"] for p in critical_updates], dry_run=False)
    else:
        logger.info("No urgent updates needed")

#!/bin/bash
# /opt/security/auto-update.sh
# Automatically executes security updates every Wednesday at 3 AM

set -euo pipefail

LOG_FILE="/var/log/security/auto-update-$(date +%Y%m%d).log"
BACKUP_DIR="/opt/security/backups/$(date +%Y%m%d)"

echo "=== Security Update Started: $(date) ===" >> "$LOG_FILE"

# 1. Create system snapshot (if LVM available)
if lvdisplay /dev/mapper/*-root >/dev/null 2>&1; then
    echo "Creating LVM snapshot..." >> "$LOG_FILE"
    lvcreate --snapshot --name update_backup \
        --size 2G /dev/mapper/*-root >> "$LOG_FILE" 2>&1
fi

# 2. Backup critical configs
mkdir -p "$BACKUP_DIR"
cp -r /etc/nginx /etc/ssh /etc/docker "$BACKUP_DIR/" 2>/dev/null
echo "Config files backed up to $BACKUP_DIR" >> "$LOG_FILE"

# 3. Run AI risk assessment
python3 /opt/security/patch-manager.py >> "$LOG_FILE" 2>&1

# 4. Execute security updates
apt-get update -qq >> "$LOG_FILE" 2>&1
apt-get upgrade -y --only-upgrade security >> "$LOG_FILE" 2>&1 || true

# 5. Restart necessary services
systemctl restart docker >> "$LOG_FILE" 2>&1 || true

echo "=== Security Update Complete: $(date) ===" >> "$LOG_FILE"

# 6. Send update notification
TELEGRAM_MSG="✅ VPS Security Update Complete\nUpdate Time: $(date '+%Y-%m-%d %H:%M')\nLog: /var/log/security/auto-update-$(date +%Y%m%d).log"
curl -s -X POST "https://api.telegram.org/bot${TG_BOT_TOKEN}/sendMessage" \
    -d "chat_id=${TG_CHAT_ID}" \
    -d "text=${TELEGRAM_MSG}" >/dev/null 2>&1

#!/usr/bin/env python3
"""
Security Incident Auto-Response Framework
Executes corresponding response playbooks based on threat type
"""

import subprocess
import json
import logging
import os
from datetime import datetime, timedelta
from typing import Dict, List

logger = logging.getLogger("incident-responder")


class IncidentResponder:
    """Incident responder"""
    
    def __init__(self):
        self.playbooks = {
            "brute_force": self._handle_brute_force,
            "malware_detected": self._handle_malware,
            "port_scan": self._handle_port_scan,
            "data_exfiltration": self._handle_data_exfiltration,
            "privilege_escalation": self._handle_privilege_escalation,
        }
    
    def detect_incident(self, log_entries: List[str]) -> Dict:
        """Detect security incidents"""
        # Brute force detection
        failed_logins = sum(1 for log in log_entries 
                          if "Failed password" in log or "authentication failure" in log)
        
        if failed_logins > 10:
            return {
                "type": "brute_force",
                "severity": "high",
                "details": f"Detected {failed_logins} failed login attempts",
                "affected_services": ["sshd"],
            }
        
        # Port scan detection
        port_connections = sum(1 for log in log_entries 
                             if "SYN_RECV" in log or "connection refused" in log.lower())
        
        if port_connections > 50:
            return {
                "type": "port_scan",
                "severity": "medium",
                "details": f"Detected {port_connections} suspicious connections",
                "affected_services": ["network"],
            }
        
        return None
    
    def execute_playbook(self, incident: Dict) -> bool:
        """Execute response playbook"""
        playbook_func = self.playbooks.get(incident["type"])
        if playbook_func:
            return playbook_func(incident)
        return False
    
    def _handle_brute_force(self, incident: Dict) -> bool:
        """Handle brute force attacks"""
        logger.info(f"Executing brute force response: {incident}")
        
        # 1. Get attacking IPs
        result = subprocess.run(
            ["journalctl", "-u", "sshd", "--since", "1 hour ago"],
            capture_output=True, text=True
        )
        
        attack_ips = set()
        for line in result.stdout.splitlines():
            if "Failed password" in line:
                parts = line.split()
                for i, part in enumerate(parts):
                    if part == "from" and i + 1 < len(parts):
                        ip = parts[i + 1]
                        attack_ips.add(ip)
        
        # 2. Block IPs
        for ip in attack_ips:
            subprocess.run(["iptables", "-A", "INPUT", "-s", ip, "-j", "DROP"],
                         capture_output=True)
            logger.info(f"Blocked IP: {ip}")
        
        # 3. Notify
        self._notify(f"🛡️ Brute force attack blocked\nBlocked {len(attack_ips)} IPs")
        
        return True
    
    def _handle_malware(self, incident: Dict) -> bool:
        """Handle malware detection"""
        logger.info("Executing malware response")
        
        # 1. Isolate affected services
        subprocess.run(["systemctl", "stop", "docker"], capture_output=True)
        
        # 2. Scan system
        subprocess.run(["clamscan", "-r", "/"], capture_output=True)
        
        # 3. Notify admin
        self._notify("🚨 Malware detected! System isolated")
        
        return True
    
    def _handle_port_scan(self, incident: Dict) -> bool:
        """Handle port scanning"""
        logger.info("Executing port scan response")
        
        # 1. Check open ports
        result = subprocess.run(["ss", "-tlnp"], capture_output=True, text=True)
        open_ports = result.stdout.strip().split("\n")[1:]
        
        # 2. Confirm unnecessary ports and close them
        allowed_ports = {"22", "80", "443", "8080"}
        for port_line in open_ports:
            port = port_line.split(":")[-1].strip()
            if port not in allowed_ports:
                logger.warning(f"Non-standard open port found: {port}")
        
        self._notify(f"🔍 Port scan detection complete\nFound {len(open_ports)} open ports")
        return True
    
    def _handle_data_exfiltration(self, incident: Dict) -> bool:
        """Handle data exfiltration"""
        logger.info("🚨 Executing data exfiltration response")
        
        # 1. Check abnormal network traffic
        result = subprocess.run(
            ["ss", "-tunap"],
            capture_output=True, text=True
        )
        
        # 2. Check abnormal file access
        subprocess.run(["find", "/", "-mtime", "-1", "-type", "f", "-size", "+100M"],
                      capture_output=True)
        
        # 3. Emergency notification
        self._notify("🚨🚨 Suspected data exfiltration! Please check server status immediately")
        return True
    
    def _handle_privilege_escalation(self, incident: Dict) -> bool:
        """Handle privilege escalation"""
        logger.info("🚨 Executing privilege escalation response")
        
        # 1. Check sudo usage records
        subprocess.run(["last", "-f", "/var/log/wtmp"], capture_output=True)
        
        # 2. Check abnormal root sessions
        subprocess.run(["w", "-h"], capture_output=True)
        
        # 3. Emergency notification
        self._notify("🚨🚨 Abnormal privilege escalation activity detected!")
        return True
    
    def _notify(self, message: str):
        """Send Telegram notification"""
        try:
            subprocess.run([
                "curl", "-s", "-X", "POST",
                f"https://api.telegram.org/bot{os.environ.get('TG_BOT_TOKEN', '')}/sendMessage",
                "-d", f"chat_id={os.environ.get('TG_CHAT_ID', '')}",
                "-d", f"text={message}",
                "-d", "parse_mode=Markdown",
            ], capture_output=True)
        except Exception:
            pass


if __name__ == "__main__":
    import os
    
    responder = IncidentResponder()
    
    # Read recent system logs
    result = subprocess.run(
        ["journalctl", "-u", "sshd", "-u", "nginx", "--since", "1 hour ago"],
        capture_output=True, text=True
    )
    
    log_entries = result.stdout.splitlines()
    
    # Detect incidents
    incident = responder.detect_incident(log_entries)
    
    if incident:
        logger.info(f"Security incident detected: {incident['type']}")
        responder.execute_playbook(incident)
    else:
        logger.info("No security incidents detected")

#!/usr/bin/env python3
"""
Generate AI Security Weekly Report
Summarizes weekly security events, vulnerability fixes, and threat intelligence
"""

import subprocess
import json
import logging
import os
from datetime import datetime, timedelta

try:
    import ollama
except ImportError:
    exit(1)

logger = logging.getLogger("weekly-report")


def generate_weekly_report():
    """Generate weekly report"""
    
    # Collect one week of security data
    week_start = (datetime.now() - timedelta(days=7)).strftime("%Y-%m-%d")
    
    # 1. Vulnerability scan results
    scan_result = subprocess.run(
        ["ls", "/var/log/security/container-scan-*"],
        capture_output=True, text=True
    )
    scan_files = scan_result.stdout.strip().split("\n")
    
    # 2. CrowdSec statistics
    cs_stats = subprocess.run(
        ["cscli", "metrics"],
        capture_output=True, text=True
    )
    
    # 3. Ban records
    bans = subprocess.run(
        ["cscli", "stories", "list", "--limit", "50"],
        capture_output=True, text=True
    )
    
    # Build report data
    report_data = {
        "week_start": week_start,
        "scan_files": len(scan_files),
        "crowdsec_stats": cs_stats.stdout,
        "bans": bans.stdout[:2000],
    }
    
    # Use LLM to generate summary
    prompt = f"""Based on the following VPS security data, generate a concise security weekly report:

{json.dumps(report_data, indent=2)}

Please include:
1. Weekly security overview (one sentence summary)
2. Main threat analysis
3. Vulnerability remediation progress
4. Next week security recommendations
5. Security score (0-100)"""
    
    response = ollama.generate(
        model="vuln-analyzer",
        prompt=prompt,
        options={"temperature": 0.3}
    )
    
    report = response.get("response", "")
    
    # Send to Telegram
    tg_token = os.environ.get("TG_BOT_TOKEN", "")
    tg_chat = os.environ.get("TG_CHAT_ID", "")
    if tg_token and tg_chat:
        subprocess.run([
            "curl", "-s", "-X", "POST",
            f"https://api.telegram.org/bot{tg_token}/sendMessage",
            "-d", f"chat_id={tg_chat}",
            "-d", f"text=*📊 Weekly Security Report*\n\n{report}",
            "-d", "parse_mode=Markdown",
        ])
    
    return report


if __name__ == "__main__":
    report = generate_weekly_report()
    print(report)