# inspection-tasks.yaml
inspection_tasks:
  - name: "system_health"
    description: "System Health Check"
    frequency: "*/5 * * * *"  # Every 5 minutes
    checks:
      - type: "cpu_usage"
        warning_threshold: 80
        critical_threshold: 95
      - type: "memory_usage"
        warning_threshold: 85
        critical_threshold: 95
      - type: "disk_usage"
        warning_threshold: 80
        critical_threshold: 90
      - type: "load_average"
        warning_threshold: 2.0
        critical_threshold: 5.0

  - name: "service_status"
    description: "Service Status Check"
    frequency: "*/10 * * * *"
    services:
      - nginx
      - docker
      - mysql
      - redis

  - name: "log_analysis"
    description: "Log Analysis"
    frequency: "*/15 * * * *"
    log_sources:
      - "/var/log/nginx/access.log"
      - "/var/log/nginx/error.log"
      - "/var/log/syslog"

  - name: "security_audit"
    description: "Security Audit"
    frequency: "0 */4 * * *"  # Every 4 hours
    checks:
      - failed_login_attempts
      - ssl_certificate_expiry
      - firewall_rules
      - open_ports

import subprocess
import json
from datetime import datetime

def generate_inspection_report():
    """Generate inspection report and send to LLM for analysis"""
    
    # Collect system metrics
    metrics = {
        "timestamp": datetime.now().isoformat(),
        "cpu": get_cpu_stats(),
        "memory": get_memory_stats(),
        "disk": get_disk_stats(),
        "network": get_network_stats(),
        "services": check_service_status()
    }
    
    # Collect recent log entries
    recent_logs = collect_recent_logs(hours=1)
    
    # Build LLM prompt
    prompt = f"""You are an experienced DevOps engineer. Please analyze the following VPS inspection data:

System Metrics:
{json.dumps(metrics, indent=2)}

Recent 1-hour log summary:
{recent_logs[:2000]}

Please provide:
1. Overall system health score (0-100)
2. Identified anomalies and their severity
3. Possible root cause analysis
4. Recommended actions
5. Whether immediate human intervention is required"""

    # Call LLM API for analysis
    analysis = call_llm_api(prompt)
    
    # Save analysis report
    save_report(metrics, analysis)
    
    return analysis

def analyze_logs_with_llm(log_content):
    """Use LLM to analyze log content"""
    
    prompt = f"""Please analyze the following server logs and provide structured output:

{log_content}

Return analysis results in JSON format, including:
- error_type: Error type classification
- severity: Severity level (info/warning/critical)
- source_component: The component that had the issue
- affected_service: Affected business service
- suggested_action: Recommended solution
- related_logs: Related log entries (if any)"""

    response = call_llm_api(prompt)
    return parse_json_response(response)

import asyncio
import logging

class RealtimeLogAnalyzer:
    def __init__(self, llm_client):
        self.llm = llm_client
        self.alert_threshold = 5  # Alert after 5 occurrences
        
    async def tail_log(self, log_path):
        """Real-time log file tracking"""
        process = await asyncio.create_subprocess_shell(
            f"tail -f {log_path}",
            stdout=asyncio.subprocess.PIPE,
            stderr=asyncio.subprocess.PIPE
        )
        
        error_counts = {}
        
        while True:
            line = await process.stdout.readline()
            if not line:
                break
                
            log_entry = line.decode('utf-8').strip()
            analysis = await self.analyze_entry(log_entry)
            
            if analysis['severity'] in ['warning', 'critical']:
                error_key = analysis['error_type']
                error_counts[error_key] = error_counts.get(error_key, 0) + 1
                
                if error_counts[error_key] >= self.alert_threshold:
                    await self.send_alert(analysis, error_counts[error_key])
                    
    async def analyze_entry(self, log_line):
        """Analyze single log entry"""
        prompt = f"Analyze the severity and type of this log:\n{log_line}"
        return self.llm.complete(prompt)

#!/bin/bash
# fix_nginx.sh

echo "Nginx anomaly detected, starting repair..."

# Check configuration syntax
nginx -t
if [ $? -ne 0 ]; then
    echo "Nginx config has syntax errors"
    cp /etc/nginx/nginx.conf.backup /etc/nginx/nginx.conf
    nginx -t
fi

# Restart Nginx
systemctl restart nginx
if [ $? -eq 0 ]; then
    echo "Nginx restarted successfully"
else
    echo "Nginx restart failed, manual intervention required"
    exit 1
fi

# Verify service health
curl -s -o /dev/null -w "%{http_code}" http://localhost/

import docker
import requests

def auto_restart_container(container_name):
    """Automatically restart unhealthy Docker containers"""
    client = docker.from_env()
    
    try:
        container = client.containers.get(container_name)
        
        # Check container health status
        health = container.attrs.get('State', {}).get('Health', {})
        status = health.get('Status', '')
        
        if status != 'healthy':
            print(f"Container {container_name} is unhealthy, preparing restart...")
            
            # Save container logs for analysis
            logs = container.logs(tail=100).decode('utf-8')
            
            # Call LLM to analyze logs
            analysis = call_llm_analyze(logs, container_name)
            
            # If LLM determines auto-fix is safe
            if analysis['can_auto_fix']:
                container.restart()
                
                # Wait for container to start
                for _ in range(30):
                    container.reload()
                    if container.status == 'running':
                        print(f"Container {container_name} restarted successfully")
                        return True
                    time.sleep(1)
            
            # Send alert
            send_alert(f"Container {container_name} restart failed", analysis)
            
    except docker.errors.NotFound:
        print(f"Container {container_name} not found")
    except Exception as e:
        print(f"Failed to restart container: {e}")

def handle_disk_full(mount_point='/'):
    """Handle disk space exhaustion"""
    usage = get_disk_usage(mount_point)
    
    if usage > 90:
        # 1. Clean old logs
        cleanup_old_logs(days=7)
        
        # 2. Clean unused Docker data
        subprocess.run(['docker', 'system', 'prune', '-f'], 
                      capture_output=True)
        
        # 3. Clean temporary files
        subprocess.run(['find', '/tmp', '-mtime', '+3', '-delete'],
                      capture_output=True)
        
        # 4. Re-check
        new_usage = get_disk_usage(mount_point)
        
        if new_usage < 80:
            return True
        else:
            # Still insufficient, requires manual intervention
            send_critical_alert(f"Disk usage still at {new_usage}% after cleanup")
            return False

# safety-rules.yaml
safety_rules:
  max_concurrent_operations: 3  # Max 3 concurrent repair operations
  cooldown_period: 300  # Minimum 300 seconds between operations
  require_approval_for:
    - "deletion_operations"
    - "configuration_changes"
    - "production_service_restarts"
  
  rollback_strategy:
    enabled: true
    auto_rollback_on_failure: true
    backup_before_change: true
    
  monitoring:
    track_all_actions: true
    alert_on_unusual_patterns: true
    daily_report: true

import time
from functools import lru_cache

class OptimizedLLMClient:
    def __init__(self, api_key, base_url):
        self.api_key = api_key
        self.base_url = base_url
        self.call_count = 0
        self.last_reset = time.time()
        
    @lru_cache(maxsize=1000)
    def cached_complete(self, prompt_hash, system_prompt, user_prompt):
        """Cache responses for identical prompts to avoid redundant calls"""
        return self._call_api(system_prompt, user_prompt)
    
    def smart_batch(self, prompts):
        """Intelligent batching to reduce API call frequency"""
        grouped = self.group_similar_prompts(prompts)
        results = []
        
        for group in grouped:
            combined_prompt = self.combine_group(group)
            result = self.cached_complete(
                hash(combined_prompt),
                "You are a DevOps expert...",
                combined_prompt
            )
            results.extend(self.split_result(result, len(group)))
            
        return results
    
    def cost_tracker(self):
        """Track API call costs"""
        elapsed = time.time() - self.last_reset
        if elapsed > 3600:
            self.call_count = 0
            self.last_reset = time.time()
        
        self.call_count += 1
        return self.call_count

SYSTEM_PROMPTS = {
    "log_analysis": """You are a senior DevOps engineer skilled at extracting key information from logs.
Analyze the following logs, identifying error types, severity, and impact scope.
Return results in JSON format.""",
    
    "incident_response": """You are handling a production environment incident.
Based on the following information, provide emergency response suggestions and long-term solutions.
Consider impact scope, recovery time, and business priority.""",
    
    "capacity_planning": """You are responsible for VPS capacity planning.
Based on current resource usage trends, provide scaling recommendations and cost optimization plans.
Consider growth expectations for the next 3 months."""
}

# 1. Clone the project
git clone https://github.com/selfvps/vps-ops-assistant.git
cd vps-ops-assistant

# 2. Create virtual environment
python3 -m venv venv
source venv/bin/activate

# 3. Install dependencies
pip install -r requirements.txt

# 4. Configure environment variables
cat > .env << EOF
LLM_API_KEY=your-api-key-here
LLM_BASE_URL=https://api.example.com/v1
EOF

# 5. Initialize database
python manage.py migrate

# 6. Start the service
python manage.py runserver --workers 4

FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 8000

CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

# docker-compose.yml
version: '3.8'

services:
  ops-assistant:
    build: .
    ports:
      - "8000:8000"
    env_file:
      - .env
    volumes:
      - ./data:/app/data
      - /var/run/docker.sock:/var/run/docker.sock
    depends_on:
      - prometheus
      - grafana
      
  prometheus:
    image: prom/prometheus:latest
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      
  grafana:
    image: grafana/grafana:latest
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin123