# docker-compose.yml
version: "3.8"

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    restart: unless-stopped
    ports:
      - "11434:11434"
    volumes:
      - ollama_data:/root/.ollama
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    environment:
      - OLLAMA_HOST=0.0.0.0
      - OLLAMA_ORIGINS=*
    # 如果需要 GPU 加速（有 NVIDIA GPU 时）
    # deploy:
    #   resources:
    #     reservations:
    #       devices:
    #         - driver: nvidia
    #           count: 1
    #           capabilities: [gpu]

volumes:
  ollama_data:

docker compose up -d

# 在 VPS 上直接拉取
curl -X POST http://localhost:11434/api/pull \
  -H "Content-Type: application/json" \
  -d '{"name": "qwen2.5:7b-instruct"}'

# 验证模型可用
curl http://localhost:11434/api/tags | jq .models

# 1.5B 超轻量版（响应快，能力弱）
curl -X POST http://localhost:11434/api/pull -d '{"name": "qwen2.5:1.5b-instruct"}'

# 3B 平衡版（推荐低配机器）
curl -X POST http://localhost:11434/api/pull -d '{"name": "qwen2.5:3b-instruct"}'

# copilot/main.py
#!/usr/bin/env python3
"""
AI Terminal Copilot — 本地 LLM 驱动的运维终端助手
"""

import os
import sys
import json
import subprocess
import argparse
from datetime import datetime
from pathlib import Path
from typing import Optional

import requests

# 配置
OLLAMA_API = os.getenv("OLLAMA_API", "http://localhost:11434")
MODEL = os.getenv("COPILOT_MODEL", "qwen2.5:7b-instruct")
SESSION_DIR = Path(os.getenv("SESSION_DIR", str(Path.home() / ".copilot/sessions")))
KNOWLEDGE_DIR = Path(os.getenv("KNOWLEDGE_DIR", str(Path.home() / ".copilot/knowledge")))
SYSTEM_CONTEXT_FILE = Path(os.getenv("SYSTEM_CONTEXT", str(Path.home() / ".copilot/system_context.txt")))

# 安全策略：禁止执行的命令前缀
DANGEROUS_PREFIXES = [
    "rm -rf /", "rm -rf /*", "mkfs", "dd if=",
    "curl ... | sh", "wget ... | bash",
    "chmod 777", "chown -R",
]

# 允许的高风险命令（需要二次确认）
REQUIRES_CONFIRMATION = [
    "systemctl stop", "systemctl restart", "docker stop",
    "docker rm", "kill ", "iptables -F",
]

def load_system_context() -> str:
    """加载系统上下文：当前服务器信息、运行的服务、关键配置摘要"""
    if SYSTEM_CONTEXT_FILE.exists():
        return SYSTEM_CONTEXT_FILE.read_text()

    context_parts = []
    # 基础系统信息
    try:
        hostname = subprocess.check_output(
            ["hostname"], text=True, stderr=subprocess.DEVNULL
        ).strip()
        uptime = subprocess.check_output(
            ["uptime", "-p"], text=True, stderr=subprocess.DEVNULL
        ).strip()
        context_parts.append(f"Hostname: {hostname}")
        context_parts.append(f"Uptime: {uptime}")
    except Exception:
        pass

    # 运行的 Docker 容器
    try:
        containers = subprocess.check_output(
            ["docker", "ps", "--format", "table {{.Names}}\t{{.Image}}\t{{.Status}}"],
            text=True, stderr=subprocess.DEVNULL
        ).strip()
        if containers:
            context_parts.append(f"\nRunning containers:\n{containers}")
    except Exception:
        pass

    # 关键服务状态
    for svc in ["nginx", "docker", "prometheus", "grafana", "ollama"]:
        try:
            status = subprocess.check_output(
                ["systemctl", "is-active", svc],
                text=True, stderr=subprocess.DEVNULL
            ).strip()
            context_parts.append(f"Service {svc}: {status}")
        except Exception:
            pass

    return "\n".join(context_parts)


def build_system_prompt(session_history: list = None) -> str:
    """构建 LLM 的系统提示词"""
    sys_ctx = load_system_context()

    prompt = f"""你是一个运行在 Linux VPS 上的 AI 运维助手（Terminal Copilot）。

## 当前系统环境
{sys_ctx}

## 你的职责
1. 理解用户的自然语言运维需求
2. 生成准确的 shell 命令来完成任务
3. 对命令输出进行解释和分析
4. 发现异常时主动给出修复建议

## 命令生成规则
- 优先使用只读命令（`--dry-run`、`-n` 参数）确认影响范围
- 涉及写入操作前先说明将要做什么
- 使用 `2>&1` 捕获 stderr，避免遗漏错误信息
- 长命令用反斜杠 `\` 换行，保持可读性
- 避免使用 `sudo`，假设用户已在 root 环境下

## 安全策略
- 不生成破坏性命令（rm -rf /、格式化磁盘等）
- 涉及服务重启、防火墙变更时，必须提示风险
- 对不确定效果的命令，先建议用 dry-run 测试

## 输出格式
对于每个请求，按以下结构回复：
- **分析**：一句话说明你在做什么
- **命令**：```bash\n{命令}\n```
- **预期输出**：简要描述预期结果（如适用）
- **注意事项**：潜在风险和后续步骤

## 已知运维知识库位置
{KNOWLEDGE_DIR}

请用中文回复。"""

    if session_history:
        prompt += "\n\n## 历史对话记录\n"
        for turn in session_history[-10:]:  # 只保留最近10轮
            prompt += f"用户: {turn['user']}\n助手: {turn['assistant']}\n"

    return prompt


def chat_with_ollama(system_prompt: str, user_message: str, stream: bool = False) -> str:
    """调用 Ollama API 进行对话"""
    payload = {
        "model": MODEL,
        "messages": [
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_message},
        ],
        "stream": stream,
        "options": {
            "temperature": 0.3,  # 运维场景需要确定性输出
            "num_ctx": 8192,
        },
    }

    try:
        resp = requests.post(
            f"{OLLAMA_API}/api/chat",
            json=payload,
            timeout=120,
            stream=stream,
        )
        resp.raise_for_status()

        if stream:
            result = ""
            for line in resp.iter_lines():
                if line:
                    chunk = json.loads(line.decode())
                    if chunk.get("message", {}).get("content"):
                        result += chunk["message"]["content"]
                        print(chunk["message"]["content"], end="", flush=True)
            print()
            return result
        else:
            data = resp.json()
            return data["message"]["content"]
    except requests.exceptions.Timeout:
        return "⚠️ 请求超时，模型可能正在加载或负载过高。"
    except requests.exceptions.ConnectionError:
        return f"⚠️ 无法连接到 Ollama ({OLLAMA_API})，请确认服务已启动。"
    except Exception as e:
        return f"⚠️ 调用 LLM 出错: {e}"


def extract_commands(response: str) -> list[str]:
    """从 LLM 回复中提取 bash 代码块中的命令"""
    import re
    # 匹配 ```bash ... ``` 或 ``` ... ``` 中的内容
    pattern = r"```(?:bash)?\s*\n(.*?)\n```"
    matches = re.findall(pattern, response, re.DOTALL)
    return [m.strip() for m in matches if m.strip()]


def execute_command(cmd: str, timeout: int = 30) -> tuple[int, str, str]:
    """在安全沙箱中执行命令"""
    # 安全检查
    for prefix in DANGEROUS_PREFIXES:
        if cmd.startswith(prefix) or prefix in cmd:
            return -1, "", f"🚫 拒绝执行危险命令: {cmd}"

    try:
        result = subprocess.run(
            cmd, shell=True, capture_output=True, text=True, timeout=timeout
        )
        return result.returncode, result.stdout, result.stderr
    except subprocess.TimeoutExpired:
        return -1, "", f"⏱️ 命令执行超时（{timeout}s）: {cmd}"
    except Exception as e:
        return -1, "", f"❌ 执行异常: {e}"


def ask_confirmation(cmd: str) -> bool:
    """对高风险命令请求确认"""
    for prefix in REQUIRES_CONFIRMATION:
        if cmd.startswith(prefix):
            answer = input(f"\n⚠️ 即将执行可能影响服务的命令:\n  {cmd}\n确认执行? (y/N) ")
            return answer.lower() == "y"
    return True


def run_copilot_interactive():
    """交互式 REPL 模式"""
    session_id = datetime.now().strftime("%Y%m%d_%H%M%S")
    session_file = SESSION_DIR / f"{session_id}.json"
    SESSION_DIR.mkdir(parents=True, exist_ok=True)

    session_history = []

    print("=" * 60)
    print("  🤖 AI Terminal Copilot — 本地运维助手")
    print(f"  模型: {MODEL}")
    print(f"  会话: {session_id}")
    print("  输入 '/exit' 退出, '/clear' 清空历史, '/run <cmd>' 执行命令")
    print("=" * 60)

    while True:
        try:
            user_input = input("\n👤 你> ").strip()
        except (EOFError, KeyboardInterrupt):
            print("\n👋 再见!")
            break

        if not user_input:
            continue

        # 特殊命令
        if user_input == "/exit":
            # 保存会话
            if session_file.exists():
                existing = json.loads(session_file.read_text())
                existing["history"].extend(session_history)
                session_file.write_text(json.dumps(existing, ensure_ascii=False, indent=2))
            print("👋 再见!")
            break

        if user_input == "/clear":
            session_history = []
            print("🗑️ 历史已清空")
            continue

        if user_input.startswith("/run "):
            cmd = user_input[5:].strip()
            if ask_confirmation(cmd):
                code, stdout, stderr = execute_command(cmd)
                print(f"\n{'='*40}")
                print(f"💻 执行结果 (exit={code}):")
                print(f"{'='*40}")
                if stdout:
                    print(f"📤 STDOUT:\n{stdout}")
                if stderr:
                    print(f"📥 STDERR:\n{stderr}")
            continue

        # 正常对话
        sys_prompt = build_system_prompt(session_history)
        reply = chat_with_ollama(sys_prompt, user_input)

        print(f"\n🤖 Copilot> {reply}")

        # 记录历史
        session_history.append({"user": user_input, "assistant": reply})

        # 自动提取并执行命令（可选功能）
        commands = extract_commands(reply)
        if commands and len(commands) <= 2:  # 只自动执行不超过2条简单命令
            auto_run = input("🔄 是否自动执行上述命令? (y/N) ").strip().lower()
            if auto_run == "y":
                for cmd in commands:
                    if ask_confirmation(cmd):
                        print(f"\n📤 执行: {cmd}")
                        code, stdout, stderr = execute_command(cmd)
                        if stdout:
                            print(stdout)
                        if stderr:
                            print(stderr, file=sys.stderr)


def run_copilot_one_shot(prompt: str, auto_exec: bool = False):
    """单次非交互式模式：适合脚本调用和 cron 任务"""
    sys_prompt = build_system_prompt()
    reply = chat_with_ollama(sys_prompt, prompt)

    print(reply)

    if auto_exec:
        commands = extract_commands(reply)
        for cmd in commands:
            print(f"\n▶️ 执行: {cmd}")
            code, stdout, stderr = execute_command(cmd)
            if stdout:
                print(stdout)
            if stderr:
                print(stderr, file=sys.stderr)


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="AI Terminal Copilot")
    parser.add_argument("-p", "--prompt", help="单次提示词模式")
    parser.add_argument("-a", "--auto-exec", action="store_true", help="自动执行生成的命令")
    args = parser.parse_args()

    if args.prompt:
        run_copilot_one_shot(args.prompt, args.auto_exec)
    else:
        run_copilot_interactive()

pip install requests
# 或
pip3 install --user requests

mkdir -p ~/.copilot/knowledge
mkdir -p ~/.copilot/sessions

# 创建系统上下文文件
cat > ~/.copilot/system_context.txt << 'EOF'
# 此文件由 Copilot 自动生成，包含当前系统的关键信息
# 每次启动时重新生成
EOF

# incidents/nginx-502-guide.md
# 标题: Nginx 502 Bad Gateway 排查指南
# 标签: nginx, 502, 故障排查

## 常见原因
1. 后端服务未启动或崩溃
2. upstream 配置错误
3. 后端响应超时（proxy_read_timeout）
4. 端口被占用或防火墙拦截

## 排查步骤
\`\`\`bash
# 1. 检查 nginx 状态
systemctl status nginx

# 2. 查看错误日志
tail -50 /var/log/nginx/error.log

# 3. 检查后端服务
curl -v http://127.0.0.1:YOUR_BACKEND_PORT/health

# 4. 检查端口监听
ss -tlnp | grep YOUR_PORT
\`\`\`

## 快速修复
\`\`\`bash
# 重启 nginx
systemctl restart nginx

# 如果是后端问题，重启对应服务
systemctl restart YOUR_SERVICE
\`\`\`

# copilot/rag.py
import os
import re
from pathlib import Path
import requests

KNOWLEDGE_DIR = Path(os.getenv("KNOWLEDGE_DIR", str(Path.home() / ".copilot/knowledge")))

def semantic_search(query: str, top_k: int = 3) -> list[dict]:
    """
    简单的关键词检索（可升级为向量检索）
    在实际生产环境中，可以接入 ChromaDB / Qdrant 做语义搜索
    """
    results = []
    query_terms = set(re.findall(r'[\u4e00-\u9fa5a-zA-Z]+', query.lower()))

    for md_file in KNOWLEDGE_DIR.rglob("*.md"):
        content = md_file.read_text(errors="ignore")
        # 提取标签
        tags = set(re.findall(r'# 标签:\s*(.+)', content))
        # 计算相关性得分
        score = 0
        title_match = 0
        # 标题匹配加分
        title_match = sum(1 for t in query_terms if t in md_file.stem.lower())
        # 内容匹配
        content_lower = content.lower()
        content_score = sum(1 for t in query_terms if t in content_lower)
        # 标签匹配加倍
        tag_score = sum(2 for t in query_terms if t in str(tags).lower())

        score = title_match * 3 + content_score + tag_score

        if score > 0:
            # 提取片段（标题 + 前200字符）
            lines = content.split('\n')
            snippet = []
            for line in lines[:5]:
                if line.strip() and not line.startswith('#'):
                    snippet.append(line.strip())
                    if len(' '.join(snippet)) > 200:
                        break

            results.append({
                "file": str(md_file.relative_to(KNOWLEDGE_DIR)),
                "score": score,
                "snippet": " ".join(snippet)[:200],
                "title": md_file.stem,
            })

    results.sort(key=lambda x: x["score"], reverse=True)
    return results[:top_k]


def enrich_prompt(base_prompt: str, query: str) -> str:
    """将检索结果注入系统提示词"""
    docs = semantic_search(query)
    if not docs:
        return base_prompt

    ctx = "\n\n## 相关运维知识库\n"
    for doc in docs:
        ctx += f"\n### [{doc['title']}] (相关性: {doc['score']})\n"
        ctx += f"{doc['snippet']}...\n"

    return base_prompt + ctx

# 编辑 crontab
crontab -e

# 添加以下行（每天凌晨2点执行）
0 2 * * * mysqldump -u root -p'YOUR_PASSWORD' --all-databases | gzip > /backup/mysql_$(date +\%Y\%m\%d).sql.gz && find /backup -name "mysql_*.sql.gz" -mtime +7 -delete

# 查看各分区使用率
df -h

# 找出根目录下最大的10个目录
du -ah / 2>/dev/null | sort -rh | head -10

# 检查 /var/log 下的日志大小
du -sh /var/log/* 2>/dev/null | sort -rh | head -10

# 检查 Docker 容器/镜像占用
docker system df

systemctl daemon-reload
systemctl enable copilot
systemctl start copilot

# 根据任务类型自动选择模型
MODEL_ROUTING = {
    "command_generation": "qwen2.5:7b-instruct",   # 复杂推理
    "log_analysis": "qwen2.5:7b-instruct",         # 文本理解
    "quick_query": "qwen2.5:3b-instruct",          # 简单问答，快速响应
    "code_review": "qwen2.5:7b-instruct",          # 代码相关
}

def get_prometheus_context(query: str) -> str:
    """从 Prometheus 获取当前关键指标，注入 LLM 上下文"""
    try:
        # 获取关键指标快照
        metrics = {
            "cpu_usage": "100 - (avg by(instance) (rate(node_cpu_seconds_total{mode=\"idle\"}[5m])) * 100)",
            "memory_usage": "(1 - (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes)) * 100",
            "disk_usage": "(1 - (node_filesystem_avail_bytes{mountpoint=\"/\"} / node_filesystem_size_bytes{mountpoint=\"/\"})) * 100",
        }
        return json.dumps(metrics, indent=2)
    except Exception:
        return ""

# copilot/web_ui.py
import streamlit as st
from copilot.main import chat_with_ollama, build_system_prompt

st.set_page_config(page_title="AI Terminal Copilot", page_icon="🤖", layout="wide")
st.title("🤖 AI Terminal Copilot")
st.caption("本地 LLM 驱动的 VPS 运维助手")

if "messages" not in st.session_state:
    st.session_state.messages = []

for msg in st.session_state.messages:
    with st.chat_message(msg["role"]):
        st.markdown(msg["content"])

if prompt := st.chat_input("输入你的运维问题..."):
    st.session_state.messages.append({"role": "user", "content": prompt})
    with st.chat_message("user"):
        st.markdown(prompt)

    sys_prompt = build_system_prompt(
        [m for m in st.session_state.messages if m["role"] == "assistant"]
    )
    with st.chat_message("assistant"):
        response = chat_with_ollama(sys_prompt, prompt)
        st.markdown(response)

    st.session_state.messages.append({"role": "assistant", "content": response})

# 1. 部署 Ollama
docker compose up -d
docker exec -it ollama ollama pull qwen2.5:7b-instruct

# 2. 安装 Copilot
mkdir -p ~/.copilot/{knowledge,sessions}
cp -r /opt/copilot/* ~/.copilot/
pip3 install --user requests

# 3. 初始化知识库
echo "# 运维知识库目录" > ~/.copilot/knowledge/README.md

# 4. 启动 Copilot
python3 ~/.copilot/main.py

# 或者单次模式
python3 ~/.copilot/main.py -p "帮我查一下 nginx 状态" --auto-exec