# Create Prometheus directory
mkdir -p ~/ai-vps-monitor/{prometheus,node-exporter,grafana}
cd ~/ai-vps-monitor

# docker-compose.yml
cat > docker-compose.yml << 'EOF'
version: "3.8"

services:
  node-exporter:
    image: prom/node-exporter:latest
    container_name: node-exporter
    restart: unless-stopped
    network_mode: host
    pid: host
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /:/rootfs:ro
    command:
      - '--path.procfs=/host/proc'
      - '--path.sysfs=/host/sys'
      - '--collector.filesystem.mount-points-exclude=^/(sys|proc|dev|host|etc)($$|/)'

  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    restart: unless-stopped
    network_mode: host
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml
      - ./prometheus/data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--storage.tsdb.retention.time=30d'
      - '--web.enable-lifecycle'

  alertmanager:
    image: prom/alertmanager:latest
    container_name: alertmanager
    restart: unless-stopped
    network_mode: host
    volumes:
      - ./prometheus/alertmanager.yml:/etc/alertmanager/alertmanager.yml
    command:
      - '--config.file=/etc/alertmanager/alertmanager.yml'
      - '--storage.path=/alertmanager'

volumes:
  prometheus-data:
EOF

# Prometheus configuration
mkdir -p prometheus
cat > prometheus/prometheus.yml << 'EOF'
global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: 'node-exporter'
    static_configs:
      - targets: ['localhost:9100']

  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']
EOF

# Alert configuration
cat > prometheus/alertmanager.yml << 'EOF'
route:
  receiver: 'default'

receivers:
  - name: 'default'
    webhook_configs:
      - url: 'http://localhost:8080/webhook'
EOF

# Start services
docker compose up -d

# Check if Node Exporter is running
curl http://localhost:9100/metrics | head -20

# Check if Prometheus collected data
curl http://localhost:9090/api/v1/targets | python3 -m json.tool

# Query CPU usage
curl 'http://localhost:9090/api/v1/query?query=100-(avg(irate(node_cpu_seconds_total{mode="idle"}[5m]))*100)'

# Deploy local inference with Ollama
curl -fsSL https://ollama.com/install.sh | sh
ollama pull llama3.2:3b

# Create a custom system prompt
ollama create ai-resource-manager -f << 'EOF'
FROM llama3.2:3b

SYSTEM """You are a VPS resource management expert. Your responsibilities are:
1. Analyze system metric data (CPU, memory, disk, network)
2. Identify load patterns and anomalies
3. Generate the optimal resource configuration based on cost constraints
4. Predict resource needs for the next 24-72 hours

Output must be in JSON format:
{
  "status": "optimal|warning|critical",
  "recommendations": [
    {
      "action": "scale_up|scale_down|migrate|optimize",
      "detail": "Specific recommendation",
      "priority": 1,
      "estimated_savings_pct": 15,
      "risk_level": "low|medium|high"
    }
  ],
  "forecast": {
    "next_24h_avg_cpu": 35,
    "next_24h_peak_cpu": 72,
    "next_24h_avg_memory_pct": 58,
    "next_72h_recommended_config": "2C4G"
  },
  "cost_analysis": {
    "current_monthly_cost": 12.5,
    "optimized_monthly_cost": 8.75,
    "potential_savings_pct": 30
  }
}
"""
EOF

pip install litellm psutil prometheus-api-client

# Configure .env
cat > .env << 'EOF'
OPENAI_API_KEY=sk-your-key
OPENAI_API_BASE=https://api.openai.com/v1
MODEL_NAME=gpt-4o-mini
PROMETHEUS_URL=http://localhost:9090
TELEGRAM_BOT_TOKEN=your-bot-token
TELEGRAM_CHAT_ID=your-chat-id
EOF

#!/usr/bin/env python3
"""AI-Driven VPS Resource Optimization Agent"""

import os
import sys
import json
import subprocess
import requests
from datetime import datetime, timedelta
from pathlib import Path
import psutil
import prometheus_api_client
import time

# Configuration
PROMETHEUS_URL = os.getenv("PROMETHEUS_URL", "http://localhost:9090")
OLLAMA_URL = os.getenv("OLLAMA_URL", "http://localhost:11434")
TELEGRAM_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN", "")
TELEGRAM_CHAT_ID = os.getenv("TELEGRAM_CHAT_ID", "")
CLOUD_API_KEY = os.getenv("CLOUD_API_KEY", "")
MIN_CPU = 1  # Minimum CPU cores
MIN_MEMORY_GB = 1  # Minimum memory in GB
COST_PER_CPU = 5.0  # Monthly cost per CPU core (USD)
COST_PER_GB = 3.0  # Monthly cost per GB of memory (USD)


class VPSOptimizer:
    def __init__(self):
        self.prom = prometheus_api_client.PrometheusConnect(
            url=PROMETHEUS_URL, disable_ssl=True
        )

    def collect_metrics(self):
        """Collect current system metrics"""
        now = datetime.now()

        # Get time-series data from Prometheus
        cpu_query = "100 - (avg(irate(node_cpu_seconds_total{mode='idle'}[5m])) * 100)"
        cpu_result = self.prom.custom_query(query=cpu_query)
        current_cpu = float(cpu_result[0]['value'][1]) if cpu_result else psutil.cpu_percent()

        memory_query = "(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100"
        mem_result = self.prom.custom_query(query=memory_query)
        current_memory = float(mem_result[0]['value'][1]) if mem_result else psutil.virtual_memory().percent

        disk_query = "100 - (node_filesystem_avail_bytes{mountpoint='/'} / node_filesystem_size_bytes{mountpoint='/'}) * 100"
        disk_result = self.prom.custom_query(query=disk_query)
        current_disk = float(disk_result[0]['value'][1]) if disk_result else psutil.disk_usage('/').percent

        network_query = "irate(node_network_receive_bytes_total[5m]) * 8 / 1000000"
        net_result = self.prom.custom_query(query=network_query)
        current_network = float(net_result[0]['value'][1]) if net_result else 0

        # Get process-level resource rankings
        top_processes = []
        for proc in psutil.process_iter(['pid', 'name', 'cpu_percent', 'memory_percent']):
            pinfo = proc.info
            if pinfo['cpu_percent'] and pinfo['cpu_percent'] > 1:
                top_processes.append({
                    "pid": pinfo['pid'],
                    "name": pinfo['name'],
                    "cpu": round(pinfo['cpu_percent'], 1),
                    "memory": round(pinfo['memory_percent'], 1)
                })
        top_processes.sort(key=lambda x: x['cpu'], reverse=True)

        return {
            "timestamp": now.isoformat(),
            "cpu_percent": round(current_cpu, 1),
            "memory_percent": round(current_memory, 1),
            "disk_percent": round(current_disk, 1),
            "network_mbps": round(current_network, 2),
            "top_processes": top_processes[:5],
            "uptime_hours": (now - datetime.fromtimestamp(psutil.boot_time())).total_seconds() / 3600
        }

    def get_historical_data(self, hours=24):
        """Get historical data for trend analysis"""
        end_time = datetime.now()
        start_time = end_time - timedelta(hours=hours)

        metrics = {}
        for metric in ["cpu", "memory"]:
            query_map = {
                "cpu": "100 - (avg(irate(node_cpu_seconds_total{mode='idle'}[5m])) * 100)",
                "memory": "(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100"
            }
            result = self.prom.query_range(
                query=query_map[metric],
                start_time=start_time.strftime("%Y-%m-%dT%H:%M:%SZ"),
                end_time=end_time.strftime("%Y-%m-%dT%H:%M:%SZ"),
                step="300s"  # 5-minute intervals
            )
            if result:
                values = [float(v[1]) for v in result[0]['values']]
                metrics[metric] = {
                    "avg": round(sum(values) / len(values), 1) if values else 0,
                    "max": round(max(values), 1) if values else 0,
                    "min": round(min(values), 1) if values else 0,
                    "data_points": len(values)
                }

        return metrics

    def generate_llm_prompt(self, current, history):
        """Generate analysis prompt for LLM"""
        top_procs = ", ".join(
            [f"{p['name']}({p['cpu']:.1f}%)" for p in current['top_processes'][:3]]
        )
        prompt = f"""You are a VPS resource management expert. Analyze the following system data and provide optimization recommendations.

## Current Status
- CPU Usage: {current['cpu_percent']}%
- Memory Usage: {current['memory_percent']}%
- Disk Usage: {current['disk_percent']}%
- Network Bandwidth: {current['network_mbps']} Mbps
- Uptime: {current['uptime_hours']:.1f} hours
- Top Processes: {top_procs}

## Historical Statistics (last 24h)
- CPU: Avg {history.get('cpu', {}).get('avg', 'N/A')}% | Max {history.get('cpu', {}).get('max', 'N/A')}% | Min {history.get('cpu', {}).get('min', 'N/A')}%
- Memory: Avg {history.get('memory', {}).get('avg', 'N/A')}% | Max {history.get('memory', {}).get('max', 'N/A')}% | Min {history.get('memory', {}).get('min', 'N/A')}%

## Constraints
- Minimum config: {MIN_CPU} CPU cores, {MIN_MEMORY_GB} GB memory
- Cost per CPU core/month: ${COST_PER_CPU}
- Cost per GB memory/month: ${COST_PER_GB}
- Current config: 2 CPU, 4 GB (monthly $19)

Output JSON only (no other text):
{{
  "status": "optimal | warning | critical",
  "recommendations": [...],
  "forecast": {{
    "next_24h_avg_cpu": ?,
    "next_24h_peak_cpu": ?,
    "next_72h_recommended_config": "?"
  }},
  "cost_analysis": {{
    "current_monthly_cost": 19,
    "optimized_monthly_cost": ?,
    "potential_savings_pct": ?
  }}
}}"""
        return prompt

    def query_llm(self, prompt):
        """Query LLM for analysis results"""
        try:
            response = requests.post(
                f"{OLLAMA_URL}/api/generate",
                json={
                    "model": "ai-resource-manager",
                    "prompt": prompt,
                    "stream": False,
                    "options": {"temperature": 0.3, "num_predict": 1024}
                },
                timeout=60
            )
            result = response.json()
            output = result.get('response', '')
            # Extract JSON part
            if "```json" in output:
                output = output.split("```json")[1].split("```")[0].strip()
            elif "```" in output:
                output = output.split("```")[1].split("```")[0].strip()
            return json.loads(output)
        except Exception as e:
            return {"status": "unknown", "error": str(e)}

    def auto_optimize(self, current):
        """Automatically execute safe optimizations"""
        optimizations = []

        # 1. Clean Docker unused resources
        try:
            subprocess.run(["docker", "system", "prune", "-f"], capture_output=True)
            optimizations.append("Cleaned unused Docker images and containers")
        except Exception:
            pass

        # 2. Clean system logs
        try:
            subprocess.run(["journalctl", "--vacuum-time", "7d"], capture_output=True)
            optimizations.append("Cleared system logs older than 7 days")
        except Exception:
            pass

        # 3. Monitor high-memory processes
        for proc_info in current.get('top_processes', []):
            if proc_info.get('memory', 0) > 50:
                optimizations.append(
                    f"Process {proc_info['name']} (PID {proc_info['pid']}) "
                    f"has high memory usage ({proc_info['memory']}%), recommend monitoring"
                )

        return "; ".join(optimizations) if optimizations else "No optimization needed"

    def send_notification(self, result):
        """Send Telegram notification"""
        if not TELEGRAM_TOKEN or not TELEGRAM_CHAT_ID:
            return

        status_emoji = {"optimal": "✅", "warning": "⚠️", "critical": "🚨", "unknown": "❓"}
        status = result.get("status", "unknown")
        emoji = status_emoji.get(status, "❓")
        cost_analysis = result.get("cost_analysis", {})
        savings = cost_analysis.get("potential_savings_pct", 0)
        forecast = result.get("forecast", {})

        message = f"""{emoji} *AI VPS Resource Optimization Report*

📊 *Status*: {status.upper()}
💰 *Potential Savings*: {savings}%
💵 *Current Monthly*: ${cost_analysis.get('current_monthly_cost', 'N/A')}
💵 *Optimized Monthly*: ${cost_analysis.get('optimized_monthly_cost', 'N/A')}

📈 *24h Forecast*:
- CPU Avg: {forecast.get('next_24h_avg_cpu', 'N/A')}%
- CPU Peak: {forecast.get('next_24h_peak_cpu', 'N/A')}%
- Recommended Config: {forecast.get('next_72h_recommended_config', 'N/A')}

🔧 *Recommendations*:
"""
        for rec in result.get("recommendations", []):
            message += f"- {rec.get('action', '')}: {rec.get('detail', '')}\n"

        requests.post(
            f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/sendMessage",
            json={"chat_id": TELEGRAM_CHAT_ID, "text": message, "parse_mode": "Markdown"}
        )

    def run_cycle(self):
        """Execute a full optimization cycle"""
        print(f"[{datetime.now().isoformat()}] Starting AI resource optimization...")

        # 1. Collect metrics
        current = self.collect_metrics()
        print(f"  CPU: {current['cpu_percent']}%, Memory: {current['memory_percent']}%")

        # 2. Get historical data
        history = self.get_historical_data(hours=24)

        # 3. Generate LLM prompt
        prompt = self.generate_llm_prompt(current, history)

        # 4. Query LLM
        llm_result = self.query_llm(prompt)
        print(f"  LLM Result: {llm_result.get('status', 'unknown')}")

        # 5. Evaluate and generate actions
        actions = []
        recommendations = llm_result.get("recommendations", [])
        for rec in recommendations:
            action = rec.get("action", "")
            if action == "scale_down" and current['cpu_percent'] < 30:
                actions.append({"type": "scale_down", "detail": rec.get("detail", ""), "confidence": "high"})
            elif action == "scale_up" and current['cpu_percent'] > 80:
                actions.append({"type": "scale_up", "detail": rec.get("detail", ""), "confidence": "high"})
            elif action == "optimize":
                optimized = self.auto_optimize(current)
                actions.append({"type": "auto_optimize", "detail": optimized, "confidence": "medium"})

        # 6. Send notification
        self.send_notification(llm_result)

        # 7. Save report
        report = {
            "timestamp": datetime.now().isoformat(),
            "metrics": current,
            "history": history,
            "llm_result": llm_result,
            "actions": actions
        }
        Path("reports").mkdir(exist_ok=True)
        report_path = f"reports/ai-report-{datetime.now().strftime('%Y%m%d-%H%M%S')}.json"
        with open(report_path, "w") as f:
            json.dump(report, f, indent=2, ensure_ascii=False)

        print(f"  Report saved: {report_path}")
        return report


if __name__ == "__main__":
    optimizer = VPSOptimizer()
    result = optimizer.run_cycle()

    # Run in daemon mode
    if "--daemon" in sys.argv:
        while True:
            time.sleep(300)  # Every 5 minutes
            try:
                optimizer.run_cycle()
            except Exception as e:
                print(f"Error: {e}")

# Install dependencies
pip3 install psutil prometheus-api-client requests

# Create runner script
cat > /usr/local/bin/ai-vps-optimizer << 'SCRIPT'
#!/bin/bash
cd /root/ai-vps-optimizer
source venv/bin/activate
python3 optimizer.py
SCRIPT

chmod +x /usr/local/bin/ai-vps-optimizer

# Add to crontab
crontab -e
# Run every hour
0 * * * * /usr/local/bin/ai-vps-optimizer >> /var/log/ai-vps-optimizer.log 2>&1

# Generate detailed report daily
0 9 * * * /usr/local/bin/ai-vps-optimizer --daily-report >> /var/log/ai-vps-optimizer.log 2>&1

# /etc/systemd/system/ai-vps-optimizer.service
[Unit]
Description=AI VPS Resource Optimizer
After=network-online.target prometheus.service
Wants=prometheus.service

[Service]
Type=simple
User=root
WorkingDirectory=/root/ai-vps-optimizer
EnvironmentFile=/root/ai-vps-optimizer/.env
ExecStart=/root/ai-vps-optimizer/venv/bin/python3 optimizer.py --daemon
Restart=on-failure
RestartSec=30
StandardOutput=append:/var/log/ai-vps-optimizer.log
StandardError=append:/var/log/ai-vps-optimizer.log

[Install]
WantedBy=multi-user.target

systemctl daemon-reload
systemctl enable --now ai-vps-optimizer
systemctl status ai-vps-optimizer

class AutoScaler:
    """Safe auto-scaling executor"""

    def __init__(self):
        self.safe_actions = {
            "clear_docker_cache": True,       # Always execute
            "vacuum_journals": True,          # Always execute
            "restart_high_memory_process": False,  # Needs confirmation
            "scale_cpu": False,               # Needs confirmation
            "scale_memory": False,            # Needs confirmation
        }

    def estimate_config_cost(self, cpu_cores, memory_gb):
        """Estimate configuration cost"""
        return 2.0 + (cpu_cores * COST_PER_CPU) + (memory_gb * COST_PER_GB)

    def recommend_config_change(self, history, current):
        """Recommend configuration changes based on historical data"""
        cpu_avg = history.get('cpu', {}).get('avg', 50)
        cpu_peak = history.get('cpu', {}).get('max', 80)
        mem_avg = history.get('memory', {}).get('avg', 60)
        mem_peak = history.get('memory', {}).get('max', 90)

        # Reserve 30% buffer space
        recommended_cpu = max(MIN_CPU, int(cpu_peak / 25) + 1)
        recommended_mem_gb = max(MIN_MEMORY_GB, int(mem_peak / 20) + 1)

        current_cost = self.estimate_config_cost(2, 4)  # Current 2C4G
        recommended_cost = self.estimate_config_cost(recommended_cpu, recommended_mem_gb)
        savings_pct = round((1 - recommended_cost / current_cost) * 100, 1)

        return {
            "current_config": "2C4G",
            "current_monthly_cost": current_cost,
            "recommended_config": f"{recommended_cpu}C{recommended_mem_gb}G",
            "recommended_monthly_cost": recommended_cost,
            "savings_pct": savings_pct,
            "reasoning": (
                f"Past 24h: CPU avg {cpu_avg}%, peak {cpu_peak}%; "
                f"Memory avg {mem_avg}%, peak {mem_peak}%. "
                f"Current config is oversized, can downgrade to {recommended_cpu}C{recommended_mem_gb}G."
            )
        }

# Install Grafana if not already done
docker run -d \
  --name grafana \
  -p 3000:3000 \
  -v ~/grafana-data:/var/lib/grafana \
  -e GF_SECURITY_ADMIN_PASSWORD=admin123 \
  grafana/grafana:latest

# CPU utilization history (for calculating over-provisioning)
100 - (avg(irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

# Memory utilization
(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100

# Disk utilization
100 - (node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"} * 100)

# Daily cost estimate (based on historical resource usage percentiles)
# 95th percentile CPU determines required CPU cores

# View recent analysis reports
ls -lt reports/ | head -10

# Check AI recommendation acceptance rate
grep -r '"action"' reports/ | wc -l  # Total recommendations
grep -r '"executed"' reports/ | wc -l  # Executed recommendations

# One-click rollback to last week's configuration
curl -X POST http://localhost:8080/api/rollback \
  -H "Authorization: Bearer your-secret-token"

# View rollback history
cat reports/rollback-history.json