feat(aiops): 新增「智能运维」——AI 日志分析（P0，不扫日志内容）

=== 为什么这样设计（成本优先）===
全集群 370GB/天，把日志原文丢给模型是不可能的（一次几百万 token）。
所以整条链路只做一件事：**把 GB 级日志压成 KB 级信号**。

P0 的信号来源全部是索引/快照，**零日志内容扫描**：
  体积 + 趋势   → index/volume_range（实测 24h 仅 54ms）
  条数/流数     → index/stats，且只在 ≤2 小时窗口用
                  （全天 index/stats 实测 20s，绝不能进 AI 路径）
  应用排行      → 平台小时级预聚合快照（毫秒）
  基线对比      → 上一个等长窗口的 volume_range
  告警          → 平台投递记录
实测一次分析：3~6 秒、输入 600~1400 tokens（约 ¥0.005/次）。

=== 后端 ===
models/ai.go            AIConfig（APIKey 加密存储）+ AIAnalysisRun（审计）
services/ai_config.go   读写配置、掩码返回、每日 token 用量统计
services/ai_provider.go OpenAI 兼容客户端 + 连通性测试
                        （DeepSeek/通义/内网 vLLM/Ollama 通用）
services/ai_redact.go   脱敏：凭据/邮箱/手机号/身份证 → 占位符，
                        **保留内网 IP 与端口**（排查必需）
services/ai_signal.go   信号采集 + 渲染成紧凑文本（省 token）
services/ai_analyze.go  结构化输出解析、配额闸门、审计落库
controllers/ai.go       /ai/config /ai/config/test /ai/analyze /ai/runs

成本闸门（三层）：
  1) 单次：时间范围 ≤24h、maxTokens ≤1500
  2) 每用户每日 token 上限（默认 50 万，可配，超限直接拒绝并说明）
  3) 审计只留最近 500 条，避免表膨胀

=== 前端 ===
新页面 /aiops（侧栏「智能运维」，管理员），页内单层 tab：
  日志分析 / 模型配置 / 分析历史
- 分析：数据源 + 时间预设(15m/1h/6h/24h) + 可选提问 → 结论/证据/建议/不确定 四区
       顶部显示本次消耗（in/out tokens、耗时），可查看「发给模型的完整内容」
- 配置：启用开关、Base URL、模型、API Key（掩码）、温度、输出上限、超时、
       每日配额、额外脱敏正则；按钮顺序改为「测试连接 → 保存配置」
- 历史：服务端分页（20/页），点行看详情与 payload

=== 两个真实踩坑（已修）===
1) 密码含 @ 导致脱敏漏掉（mysql://user:P@ssw0rd@host）
   → URL basic-auth 规则改为贪婪匹配到最后一个 @，由单测锁定
2) 结论里的时间是 UTC（容器无 tzdata，time.Local=UTC），
   模型写"凌晨 6 点下跌"而运维当时是下午 2 点
   → 显式用东八区展示（LOKISTACK_DISPLAY_TZ=UTC 可覆盖）

=== 实测（69147008fcf4）===
  配置保存 → key 掩码 sk-***e286；连通性测试返回「正常」
  分析 15 分钟窗口：4.1s，结论识别出"窗口末段体积断崖约 -60%"
  信号时间 14:23~14:38（本地时间正确）
  历史分页 total=3，tokens/耗时字段完整
  单测：脱敏 2 个用例 + 模型输出解析 4 个用例 + 6 条 AI 路由断言

backend/services/ai_analyze.go

@@ -0,0 +1,243 @@
+package services
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strings"
+	"time"
+
+	"lokistack/models"
+	"lokistack/repository"
+)
+
+// AIAnalysisResult 结构化结论。
+//
+// 强制模型输出这个结构而不是自由文本，原因：
+//  1. 前端能分区渲染（结论/证据/建议/不确定），可读性远好于一段散文；
+//  2. 每条结论都要挂 evidence，逼模型把话落在数据上，降低编造；
+//  3. unknowns 单独一栏，明确"不知道什么"比编一个答案有价值得多。
+type AIAnalysisResult struct {
+	Summary  string      `json:"summary"`
+	Findings []AIFinding `json:"findings"`
+	Actions  []string    `json:"actions"`
+	Unknowns []string    `json:"unknowns"`
+	RawText  string      `json:"-"`
+	ParseErr string      `json:"parseError,omitempty"`
+}
+
+type AIFinding struct {
+	Title    string `json:"title"`
+	Evidence string `json:"evidence"`
+	Severity string `json:"severity"` // high | medium | low
+}
+
+// AIAnalysisOutcome 一次分析的完整返回（含成本信息）。
+type AIAnalysisOutcome struct {
+	Result   AIAnalysisResult     `json:"result"`
+	Signals  *AISignalBundle      `json:"signals"`
+	Prompt   string               `json:"prompt"`
+	Run      models.AIAnalysisRun `json:"run"`
+	Warnings []string             `json:"warnings"`
+}
+
+const aiSystemPrompt = `你是资深 SRE，负责分析 Loki 日志平台的运行状况。
+
+严格规则：
+1. 只能基于我给你的"信号数据"下结论。**不许编造**日志内容、错误信息、时间点或服务名。
+2. 每一条结论都必须在 evidence 里引用信号数据中的具体数字或条目。
+3. 如果信号数据不足以判断根因，把它写进 unknowns，不要猜。
+4. 你看不到日志原文（只有统计与排行），因此不要描述"日志里写了什么"。
+5. 输出必须是**单个 JSON 对象**，不要 markdown 代码块，不要任何解释性前后缀。
+
+JSON 结构：
+{
+  "summary": "两三句话的整体判断",
+  "findings": [{"title": "简短结论", "evidence": "引用具体数据", "severity": "high|medium|low"}],
+  "actions": ["可执行的下一步动作，按优先级排序"],
+  "unknowns": ["无法从当前数据判断的点"]
+}`
+
+// RunAIAnalysis 执行一次分析：采集信号 → 脱敏 → 调模型 → 解析 → 落审计。
+func RunAIAnalysis(ctx context.Context, cfg models.AIConfig, src *models.LogSource, userID uint, username string, admin bool, from, to time.Time, question string) (*AIAnalysisOutcome, error) {
+	if !cfg.Enabled {
+		return nil, fmt.Errorf("AI 分析未启用：请先在「智能运维 → 模型配置」中开启并保存")
+	}
+
+	// ── 每日配额闸门（成本控制第一层）──
+	if cfg.DailyTokenCap > 0 {
+		used := AITokenUsedToday(userID)
+		if used >= cfg.DailyTokenCap {
+			run := models.AIAnalysisRun{
+				UserID: userID, Username: username, SourceID: src.ID, SourceName: src.Name,
+				Status: "quota-exceeded", Error: fmt.Sprintf("今日 AI token 用量已达上限（%d/%d）", used, cfg.DailyTokenCap),
+				CreatedAt: time.Now(),
+			}
+			persistAIRun(&run)
+			return nil, fmt.Errorf("今日 AI 用量已达上限（%d/%d tokens），可在模型配置中调整上限或明天再试", used, cfg.DailyTokenCap)
+		}
+	}
+
+	started := time.Now()
+	signals, err := CollectAISignals(ctx, src, userID, admin, from, to)
+	if err != nil {
+		return nil, err
+	}
+	// 扫描预算闸门：P0 全是索引/快照，实际扫描为 0，这里留出扩展位
+	if cfg.MaxScanBytes > 0 && signals.TotalBytes > cfg.MaxScanBytes*8 {
+		signals.Warnings = append(signals.Warnings,
+			fmt.Sprintf("该范围日志体积 %.1f GB 偏大，已只使用索引统计（未读取日志内容）",
+				float64(signals.TotalBytes)/1024/1024/1024))
+	}
+
+	// ── 脱敏（第二层：隐私）──
+	rawPrompt := SignalsAsText(signals)
+	redacted, invalidRules := RedactText(rawPrompt, cfg.RedactExtra)
+	if question = strings.TrimSpace(question); question != "" {
+		redacted += "\n\n运维补充的问题：" + RedactTextOnly(question, cfg.RedactExtra)
+	}
+	warnings := append([]string{}, signals.Warnings...)
+	for _, r := range invalidRules {
+		warnings = append(warnings, "额外脱敏规则无效已跳过："+r)
+	}
+
+	// ── 调模型 ──
+	reply, promptTokens, completionTokens, callErr := aiChat(ctx, cfg, []aiMessage{
+		{Role: "system", Content: aiSystemPrompt},
+		{Role: "user", Content: redacted},
+	})
+
+	run := models.AIAnalysisRun{
+		UserID: userID, Username: username, SourceID: src.ID, SourceName: src.Name,
+		RangeMinutes: signals.RangeMinutes, Model: cfg.Model, Question: question,
+		PromptPayload: truncateStr(redacted, 20000),
+		PromptTokens:  promptTokens, CompletionTokens: completionTokens,
+		ScanBytes:  0, // P0 不扫内容
+		DurationMs: time.Since(started).Milliseconds(),
+		CreatedAt:  time.Now(),
+	}
+	if callErr != nil {
+		run.Status = "failed"
+		run.Error = callErr.Error()
+		run.DurationMs = time.Since(started).Milliseconds()
+		persistAIRun(&run)
+		return nil, callErr
+	}
+
+	result := parseAIResult(reply)
+	conclusion, _ := json.Marshal(result)
+	run.Status = "ok"
+	run.Conclusion = string(conclusion)
+	run.DurationMs = time.Since(started).Milliseconds()
+	persistAIRun(&run)
+
+	return &AIAnalysisOutcome{
+		Result: result, Signals: signals, Prompt: redacted, Run: run, Warnings: warnings,
+	}, nil
+}
+
+// RedactTextOnly 只脱敏不做规则校验提示（用于短文本如用户提问）。
+func RedactTextOnly(text string, extra []string) string {
+	out, _ := RedactText(text, extra)
+	return out
+}
+
+// parseAIResult 宽松解析模型输出。
+//
+// 模型常见的"不听话"有三种：包了 ```json 代码块、前后加了解释、
+// 直接返回纯文本。前两种剥壳后重试，第三种降级为 summary=原文，
+// 保证用户至少能看到内容，而不是一个"解析失败"。
+func parseAIResult(reply string) AIAnalysisResult {
+	text := strings.TrimSpace(reply)
+	text = strings.TrimPrefix(text, "```json")
+	text = strings.TrimPrefix(text, "```")
+	text = strings.TrimSuffix(text, "```")
+	text = strings.TrimSpace(text)
+	if idx := strings.Index(text, "{"); idx > 0 {
+		text = text[idx:]
+	}
+	if end := strings.LastIndex(text, "}"); end >= 0 && end < len(text)-1 {
+		text = text[:end+1]
+	}
+
+	var parsed AIAnalysisResult
+	if err := json.Unmarshal([]byte(text), &parsed); err == nil && (parsed.Summary != "" || len(parsed.Findings) > 0) {
+		return parsed
+	}
+	return AIAnalysisResult{
+		Summary:  strings.TrimSpace(reply),
+		Findings: []AIFinding{},
+		Actions:  []string{},
+		Unknowns: []string{},
+		RawText:  reply,
+		ParseErr: "模型未按 JSON 格式返回，已按纯文本展示",
+	}
+}
+
+// persistAIRun 落审计（同时用于每日 token 统计）。
+func persistAIRun(run *models.AIAnalysisRun) {
+	db := repository.GetDB()
+	if db == nil {
+		return
+	}
+	newID := db.NextID("aiAnalysisRuns")
+	db.Lock()
+	defer db.Unlock()
+	run.ID = newID
+	db.AIAnalysisRuns = append(db.AIAnalysisRuns, *run)
+	// 只保留最近 500 条，避免审计表无限膨胀（明细可通过日志追溯）
+	if len(db.AIAnalysisRuns) > 500 {
+		db.AIAnalysisRuns = db.AIAnalysisRuns[len(db.AIAnalysisRuns)-500:]
+	}
+	db.RequestSave()
+}
+
+// ListAIRuns 分页查询审计记录（按时间倒序）。
+func ListAIRuns(page, pageSize int) ([]models.AIAnalysisRun, int) {
+	if page <= 0 {
+		page = 1
+	}
+	if pageSize <= 0 || pageSize > 100 {
+		pageSize = 20
+	}
+	db := repository.GetDB()
+	if db == nil {
+		return nil, 0
+	}
+	db.RLock()
+	all := make([]models.AIAnalysisRun, len(db.AIAnalysisRuns))
+	copy(all, db.AIAnalysisRuns)
+	db.RUnlock()
+
+	total := len(all)
+	// 倒序（新的在前）
+	for i, j := 0, len(all)-1; i < j; i, j = i+1, j-1 {
+		all[i], all[j] = all[j], all[i]
+	}
+	start := (page - 1) * pageSize
+	if start >= total {
+		return []models.AIAnalysisRun{}, total
+	}
+	end := start + pageSize
+	if end > total {
+		end = total
+	}
+	return all[start:end], total
+}
+
+// GetAIRun 取单条审计记录（用于查看完整 payload）。
+func GetAIRun(id uint) *models.AIAnalysisRun {
+	db := repository.GetDB()
+	if db == nil {
+		return nil
+	}
+	db.RLock()
+	defer db.RUnlock()
+	for i := range db.AIAnalysisRuns {
+		if db.AIAnalysisRuns[i].ID == id {
+			run := db.AIAnalysisRuns[i]
+			return &run
+		}
+	}
+	return nil
+}

backend/services/ai_config.go

@@ -0,0 +1,185 @@
+package services
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+	"time"
+
+	"lokistack/models"
+	"lokistack/pkg/crypto"
+	"lokistack/repository"
+)
+
+const aiConfigSettingKey = "ai_config"
+
+// 成本相关的默认值（宁可保守：额度小、扫描少，用户觉得不够再调）
+const (
+	defaultAIMaxTokens     = 1500
+	defaultAITimeoutSec    = 120
+	defaultAITemperature   = 0.1 // 分析场景要稳定复现，不要发挥
+	defaultAIDailyTokenCap = 500000
+	defaultAIMaxScanBytes  = 2 << 30 // 2GiB
+)
+
+// GetAIConfig 读配置（返回真实 APIKey，仅供内部调用）。
+func GetAIConfig() models.AIConfig {
+	cfg := models.AIConfig{
+		Provider:      "openai-compatible",
+		Temperature:   defaultAITemperature,
+		MaxTokens:     defaultAIMaxTokens,
+		TimeoutSec:    defaultAITimeoutSec,
+		DailyTokenCap: defaultAIDailyTokenCap,
+		MaxScanBytes:  defaultAIMaxScanBytes,
+	}
+	db := repository.GetDB()
+	if db == nil {
+		return cfg
+	}
+	db.RLock()
+	raw := ""
+	for _, s := range db.Settings {
+		if s.Key == aiConfigSettingKey {
+			raw = s.Value
+			break
+		}
+	}
+	db.RUnlock()
+	if raw == "" {
+		return cfg
+	}
+	var stored models.AIConfig
+	if err := json.Unmarshal([]byte(raw), &stored); err != nil {
+		return cfg
+	}
+	if stored.APIKey != "" {
+		stored.APIKey = crypto.DecryptField(stored.APIKey)
+	}
+	if stored.Provider == "" {
+		stored.Provider = "openai-compatible"
+	}
+	if stored.MaxTokens <= 0 {
+		stored.MaxTokens = defaultAIMaxTokens
+	}
+	if stored.TimeoutSec <= 0 {
+		stored.TimeoutSec = defaultAITimeoutSec
+	}
+	if stored.MaxScanBytes <= 0 {
+		stored.MaxScanBytes = defaultAIMaxScanBytes
+	}
+	return stored
+}
+
+// MaskedAIConfig 返回给前端的版本：APIKey 只留头尾。
+func MaskedAIConfig() models.AIConfig {
+	cfg := GetAIConfig()
+	cfg.APIKey = maskKey(cfg.APIKey)
+	return cfg
+}
+
+func maskKey(key string) string {
+	if key == "" {
+		return ""
+	}
+	if len(key) <= 8 {
+		return "***"
+	}
+	return key[:3] + "***" + key[len(key)-4:]
+}
+
+// SaveAIConfig 保存配置。
+//
+// apiKey 传空 = 沿用旧值（前端拿到的是掩码，不能把掩码存回去）；
+// 传 "***" 开头的掩码也视为沿用，避免用户只是改模型名却把 key 清空。
+func SaveAIConfig(in models.AIConfig, apiKey string) error {
+	old := GetAIConfig()
+	key := strings.TrimSpace(apiKey)
+	switch {
+	case key == "":
+		key = old.APIKey
+	case strings.Contains(key, "***"):
+		key = old.APIKey
+	}
+	if in.Enabled && (strings.TrimSpace(in.BaseURL) == "" || strings.TrimSpace(in.Model) == "") {
+		return fmt.Errorf("启用 AI 分析需要填写 Base URL 与模型名")
+	}
+	if in.Enabled && key == "" {
+		return fmt.Errorf("启用 AI 分析需要填写 API Key（内网无鉴权的服务可填任意占位值）")
+	}
+	if in.BaseURL != "" && !strings.HasPrefix(in.BaseURL, "http") {
+		return fmt.Errorf("Base URL 必须以 http:// 或 https:// 开头（例如 https://api.deepseek.com/v1）")
+	}
+
+	enc, err := crypto.EncryptField(key)
+	if err != nil {
+		return fmt.Errorf("加密 API Key 失败: %w", err)
+	}
+	saved := models.AIConfig{
+		Enabled:       in.Enabled,
+		Provider:      "openai-compatible",
+		BaseURL:       strings.TrimSuffix(strings.TrimSpace(in.BaseURL), "/"),
+		APIKey:        enc,
+		Model:         strings.TrimSpace(in.Model),
+		Temperature:   in.Temperature,
+		MaxTokens:     in.MaxTokens,
+		TimeoutSec:    in.TimeoutSec,
+		DailyTokenCap: in.DailyTokenCap,
+		MaxScanBytes:  in.MaxScanBytes,
+		RedactExtra:   in.RedactExtra,
+	}
+	if saved.MaxTokens <= 0 {
+		saved.MaxTokens = defaultAIMaxTokens
+	}
+	if saved.TimeoutSec <= 0 {
+		saved.TimeoutSec = defaultAITimeoutSec
+	}
+	if saved.MaxScanBytes <= 0 {
+		saved.MaxScanBytes = defaultAIMaxScanBytes
+	}
+	data, err := json.Marshal(saved)
+	if err != nil {
+		return err
+	}
+
+	db := repository.GetDB()
+	if db == nil {
+		return fmt.Errorf("数据库未初始化")
+	}
+	newID := db.NextID("settings")
+	db.Lock()
+	defer db.Unlock()
+	for i := range db.Settings {
+		if db.Settings[i].Key == aiConfigSettingKey {
+			db.Settings[i].Value = string(data)
+			db.RequestSave()
+			return nil
+		}
+	}
+	db.Settings = append(db.Settings, models.SystemSetting{ID: newID, Key: aiConfigSettingKey, Value: string(data)})
+	db.RequestSave()
+	return nil
+}
+
+// truncateToDay 取当天 00:00（本地时区），用于"今日已用 token"统计。
+func truncateToDay() time.Time {
+	now := time.Now()
+	return time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
+}
+
+// AITokenUsedToday 某用户今日已消耗的 token 总量（每日配额闸门用）。
+func AITokenUsedToday(userID uint) int {
+	db := repository.GetDB()
+	if db == nil {
+		return 0
+	}
+	today := truncateToDay()
+	db.RLock()
+	defer db.RUnlock()
+	total := 0
+	for _, r := range db.AIAnalysisRuns {
+		if r.UserID == userID && !r.CreatedAt.Before(today) {
+			total += r.PromptTokens + r.CompletionTokens
+		}
+	}
+	return total
+}

backend/services/ai_provider.go

@@ -0,0 +1,128 @@
+package services
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+
+	"lokistack/models"
+)
+
+// OpenAI 兼容 Chat Completions 客户端。
+//
+// 只依赖 /chat/completions 这一个端点，所以 DeepSeek、通义、
+// 内网 vLLM、Ollama(/v1)、各类网关都能直接用，不需要按厂商写适配。
+
+type aiMessage struct {
+	Role    string `json:"role"`
+	Content string `json:"content"`
+}
+
+type aiChatRequest struct {
+	Model       string      `json:"model"`
+	Messages    []aiMessage `json:"messages"`
+	Temperature float64     `json:"temperature"`
+	MaxTokens   int         `json:"max_tokens,omitempty"`
+	Stream      bool        `json:"stream"`
+}
+
+type aiChatResponse struct {
+	Choices []struct {
+		Message struct {
+			Content string `json:"content"`
+		} `json:"message"`
+		FinishReason string `json:"finish_reason"`
+	} `json:"choices"`
+	Usage struct {
+		PromptTokens     int `json:"prompt_tokens"`
+		CompletionTokens int `json:"completion_tokens"`
+		TotalTokens      int `json:"total_tokens"`
+	} `json:"usage"`
+	Error *struct {
+		Message string `json:"message"`
+		Type    string `json:"type"`
+	} `json:"error"`
+}
+
+// aiChat 调一次对话补全。
+//
+// 错误信息必须具体：把上游返回的 message 原样带出来，不要包装成
+// "调用失败" —— 常见原因（key 错、模型名不存在、baseURL 路径少了 /v1、
+// 内网模型没起）都在上游 message 里，藏起来只会让用户去猜。
+func aiChat(ctx context.Context, cfg models.AIConfig, messages []aiMessage) (string, int, int, error) {
+	if strings.TrimSpace(cfg.BaseURL) == "" || strings.TrimSpace(cfg.Model) == "" {
+		return "", 0, 0, fmt.Errorf("未配置模型：请先在「智能运维 → 模型配置」填写 Base URL 与模型名")
+	}
+	url := strings.TrimSuffix(cfg.BaseURL, "/") + "/chat/completions"
+	body, err := json.Marshal(aiChatRequest{
+		Model:       cfg.Model,
+		Messages:    messages,
+		Temperature: cfg.Temperature,
+		MaxTokens:   cfg.MaxTokens,
+		Stream:      false,
+	})
+	if err != nil {
+		return "", 0, 0, err
+	}
+
+	timeout := time.Duration(cfg.TimeoutSec) * time.Second
+	if timeout <= 0 {
+		timeout = 120 * time.Second
+	}
+	reqCtx, cancel := context.WithTimeout(ctx, timeout)
+	defer cancel()
+
+	req, err := http.NewRequestWithContext(reqCtx, http.MethodPost, url, bytes.NewReader(body))
+	if err != nil {
+		return "", 0, 0, fmt.Errorf("构造请求失败: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+	if cfg.APIKey != "" {
+		req.Header.Set("Authorization", "Bearer "+cfg.APIKey)
+	}
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		if reqCtx.Err() == context.DeadlineExceeded {
+			return "", 0, 0, fmt.Errorf("模型响应超时（%d 秒）：可调大「超时」或换更快的模型", cfg.TimeoutSec)
+		}
+		return "", 0, 0, fmt.Errorf("连接模型服务失败: %w", err)
+	}
+	defer resp.Body.Close()
+
+	raw, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<20))
+	if resp.StatusCode >= 400 {
+		var parsed aiChatResponse
+		if json.Unmarshal(raw, &parsed) == nil && parsed.Error != nil && parsed.Error.Message != "" {
+			return "", 0, 0, fmt.Errorf("模型返回 %d：%s", resp.StatusCode, parsed.Error.Message)
+		}
+		return "", 0, 0, fmt.Errorf("模型返回 %d：%s", resp.StatusCode, truncateStr(string(raw), 300))
+	}
+
+	var parsed aiChatResponse
+	if err := json.Unmarshal(raw, &parsed); err != nil {
+		return "", 0, 0, fmt.Errorf("解析模型响应失败（可能不是 OpenAI 兼容接口）: %s", truncateStr(string(raw), 200))
+	}
+	if len(parsed.Choices) == 0 {
+		return "", 0, 0, fmt.Errorf("模型没有返回任何内容（finish_reason 为空）")
+	}
+	return parsed.Choices[0].Message.Content, parsed.Usage.PromptTokens, parsed.Usage.CompletionTokens, nil
+}
+
+// TestAIConnection 连通性测试：发一句最小请求，验证 baseURL/key/model 三件套。
+func TestAIConnection(cfg models.AIConfig) (string, error) {
+	cfg.MaxTokens = 32
+	cfg.TimeoutSec = 30
+	reply, _, _, err := aiChat(context.Background(), cfg, []aiMessage{
+		{Role: "user", Content: "只回复两个字：正常"},
+	})
+	if err != nil {
+		return "", err
+	}
+	return strings.TrimSpace(reply), nil
+}

backend/services/ai_redact.go

@@ -0,0 +1,64 @@
+package services
+
+import (
+	"regexp"
+	"strings"
+)
+
+// 脱敏：日志里经常夹带凭据，送给外部模型前必须处理。
+//
+// 原则：
+//   - 宁可多脱一点，也不能漏掉凭据；
+//   - 但**不要脱掉排查必需的信息**：内网 IP、端口、主机名、命名空间、
+//     Pod 名、错误码都要保留，否则模型给不出有用结论。
+//   - 每条规则都替换成带类型的占位符（<IP> / <TOKEN>），
+//     这样模型仍能看出"这里原本是个 token"，语义不丢。
+
+type redactRule struct {
+	pattern     *regexp.Regexp
+	replacement string
+}
+
+var builtinRedactRules = []redactRule{
+	// Bearer / JWT —— 一定是凭据
+	{regexp.MustCompile(`(?i)bearer\s+[A-Za-z0-9\-._~+/]{12,}=*`), "Bearer <TOKEN>"},
+	{regexp.MustCompile(`\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{4,}`), "<JWT>"},
+	// key=value 形式的敏感字段
+	{regexp.MustCompile(`(?i)\b(password|passwd|pwd|secret|token|api[_-]?key|access[_-]?key|secret[_-]?key)\b\s*[=:]\s*("?[^\s"',;]{4,}"?)`), "$1=<REDACTED>"},
+	// URL 里的 basic auth：scheme://user:pass@host
+	// 密码里可能含 @（如 P@ssw0rd），所以取到**最后一个 @** 之前的所有内容：
+	// 用贪婪 [^\s/]+ 再回溯到最后一个 @，能正确切出 password 与 host。
+	{regexp.MustCompile(`://([^:/\s]+):([^\s/]+)@`), "://$1:<REDACTED>@"},
+	// AK/SK 形式（云厂商常见 16~40 位字母数字混合，带已知前缀）
+	{regexp.MustCompile(`\b(AKIA|LTAI|AKID)[A-Za-z0-9]{12,}\b`), "<CLOUD_AK>"},
+	// 手机号 / 身份证
+	{regexp.MustCompile(`\b1[3-9]\d{9}\b`), "<PHONE>"},
+	{regexp.MustCompile(`\b\d{17}[\dXx]\b`), "<ID_CARD>"},
+	// 邮箱
+	{regexp.MustCompile(`\b[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}\b`), "<EMAIL>"},
+}
+
+// RedactText 对文本做脱敏，extra 是用户在设置里加的额外正则。
+//
+// 额外正则写错（如括号不闭合）不能让整个分析失败：静默跳过，
+// 但上层会把这些失效规则一并提示给用户。
+func RedactText(text string, extra []string) (string, []string) {
+	out := text
+	for _, rule := range builtinRedactRules {
+		out = rule.pattern.ReplaceAllString(out, rule.replacement)
+	}
+	var invalid []string
+	for _, raw := range extra {
+		raw = strings.TrimSpace(raw)
+		if raw == "" {
+			continue
+		}
+		re, err := regexp.Compile(raw)
+		if err != nil {
+			invalid = append(invalid, raw)
+			continue
+		}
+		out = re.ReplaceAllString(out, "<REDACTED>")
+	}
+	return out, invalid
+}

backend/services/ai_redact_test.go

@@ -0,0 +1,87 @@
+package services
+
+import (
+	"strings"
+	"testing"
+)
+
+// 脱敏的两条底线：
+//   1) 凭据必须挡住（否则把 key 发给外部模型）；
+//   2) 排查必需的信息必须留着（IP/端口/命名空间/错误码），
+//      否则模型给不出有用结论 —— 这比"脱得太干净"更常见。
+func TestRedactText(t *testing.T) {
+	in := `2026-10-30 12:00:01 ERROR redis client: dial tcp 172.19.16.17:6379: connect: connection refused
+password=Sup3rS3cret! user-admin
+Authorization: Bearer eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abcdefghijklmn
+url: mysql://appuser:P@ssw0rd@10.2.3.4:3306/cex
+contact: ops@example.com phone: 13800138000
+accessKey=AKIAIOSFODNN7EXAMPLE`
+
+	out, invalid := RedactText(in, nil)
+	if len(invalid) != 0 {
+		t.Fatalf("内置规则不应产生无效正则: %v", invalid)
+	}
+
+	mustRedact := []string{"Sup3rS3cret", "eyJhbGciOiJIUzI1NiJ9", "P@ssw0rd", "ops@example.com", "13800138000", "AKIAIOSFODNN7EXAMPLE"}
+	for _, secret := range mustRedact {
+		if strings.Contains(out, secret) {
+			t.Errorf("敏感内容未脱敏: %q\n%s", secret, out)
+		}
+	}
+
+	mustKeep := []string{"172.19.16.17:6379", "connection refused", "10.2.3.4:3306", "redis"}
+	for _, keep := range mustKeep {
+		if !strings.Contains(out, keep) {
+			t.Errorf("排查必需的信息被误删: %q\n%s", keep, out)
+		}
+	}
+}
+
+// 用户自定义正则写错不能拖垮整次分析：跳过并在返回值里报告。
+func TestRedactTextInvalidExtraRule(t *testing.T) {
+	out, invalid := RedactText("hello internal-id-12345", []string{`(unclosed`, `internal-id-\d+`})
+	if len(invalid) != 1 || invalid[0] != `(unclosed` {
+		t.Errorf("应报告 1 条无效规则，实际 %v", invalid)
+	}
+	if strings.Contains(out, "internal-id-12345") {
+		t.Errorf("有效自定义规则应生效: %s", out)
+	}
+}
+
+// 模型经常不按 JSON 返回，解析必须宽容，不能只报"解析失败"。
+func TestParseAIResultTolerance(t *testing.T) {
+	cases := []struct {
+		name string
+		in   string
+		want string // 期望的 summary 片段
+	}{
+		{
+			name: "标准 JSON",
+			in:   `{"summary":"日志量正常","findings":[],"actions":[],"unknowns":[]}`,
+			want: "日志量正常",
+		},
+		{
+			name: "包了 ```json 代码块",
+			in:   "```json\n{\"summary\":\"体积上涨 2 倍\",\"findings\":[{\"title\":\"t\",\"evidence\":\"e\",\"severity\":\"high\"}],\"actions\":[],\"unknowns\":[]}\n```",
+			want: "体积上涨 2 倍",
+		},
+		{
+			name: "前后加了解释",
+			in:   `分析如下：{"summary":"存在告警","findings":[],"actions":[],"unknowns":[]} 希望有帮助`,
+			want: "存在告警",
+		},
+		{
+			name: "纯文本（降级）",
+			in:   "看起来一切正常，没有异常日志。",
+			want: "看起来一切正常",
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			got := parseAIResult(c.in)
+			if !strings.Contains(got.Summary, c.want) {
+				t.Errorf("summary 不符: got %q want contains %q", got.Summary, c.want)
+			}
+		})
+	}
+}

backend/services/ai_signal.go

@@ -0,0 +1,279 @@
+package services
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"sort"
+	"strings"
+	"time"
+
+	"lokistack/models"
+	"lokistack/repository"
+)
+
+// AI 分析的"信号包"：把 GB 级日志压成 KB 级结构化数据。
+//
+// 成本优先原则（P0 的硬约束）：
+//   - 体积/趋势 → index/volume_range（实测 24h 仅 54ms，不读日志内容）
+//   - 条数/流数 → index/stats，只允许在 ≤2 小时窗口上用
+//     （全天 index/stats 实测 20 秒，绝不能进 AI 路径）
+//   - 应用排行 → 平台按小时预聚合的快照（毫秒级）
+//   - 告警 → 平台库
+//
+// 也就是说：**P0 完全不扫日志内容**，一次分析对 Loki 的压力接近 0。
+type AISignalBundle struct {
+	SourceID     uint   `json:"sourceId"`
+	SourceName   string `json:"sourceName"`
+	Selector     string `json:"selector"`
+	From         string `json:"from"`
+	To           string `json:"to"`
+	RangeMinutes int    `json:"rangeMinutes"`
+
+	TotalBytes   int64 `json:"totalBytes"`
+	TotalEntries int64 `json:"totalEntries"`
+	// EntriesExact 条数是否为精确值（false = 范围过大跳过了 index/stats）
+	EntriesExact bool `json:"entriesExact"`
+
+	Streams int64 `json:"streams"`
+	Chunks  int64 `json:"chunks"`
+
+	Trend []AITrendPoint `json:"trend"`
+	Apps  []AISignalApp  `json:"apps"`
+
+	Baseline *AIBaseline `json:"baseline,omitempty"`
+	Alerts   []AIAlert   `json:"alerts"`
+
+	// SnapshotHours 平台按小时预聚合已留存的小时数（影响排行的可信度）
+	SnapshotHours int `json:"snapshotHours"`
+	// Warnings 采集过程中的降级说明（如"范围过大，条数为估算"）
+	Warnings []string `json:"warnings"`
+}
+
+// aiDisplayZone 结论中展示时间用的时区。
+//
+// 为什么不直接用 time.Local：静态编译的容器镜像通常没有 /usr/share/zoneinfo，
+// TZ 也没设，time.Local 就是 UTC —— 结果是模型在结论里写"凌晨 6 点日志下跌"，
+// 而运维当时是下午 2 点，直接被当成数据错误。
+// 默认东八区（本地运维环境），需要别的时区可用 LOKISTACK_DISPLAY_TZ=UTC 覆盖。
+func aiDisplayZone() *time.Location {
+	if strings.EqualFold(strings.TrimSpace(os.Getenv("LOKISTACK_DISPLAY_TZ")), "UTC") {
+		return time.UTC
+	}
+	return time.FixedZone("CST", 8*3600)
+}
+
+type AITrendPoint struct {
+	Time  string `json:"time"`
+	Bytes int64  `json:"bytes"`
+}
+
+type AISignalApp struct {
+	App       string `json:"app"`
+	Namespace string `json:"namespace"`
+	Entries   int64  `json:"entries"`
+	Bytes     int64  `json:"bytes"`
+	Share     string `json:"share"`
+}
+
+type AIBaseline struct {
+	// PreviousBytes 上一周期同时长的体积（等长窗口对比）
+	PreviousBytes  int64   `json:"previousBytes"`
+	CurrentBytes   int64   `json:"currentBytes"`
+	DeltaPercent   float64 `json:"deltaPercent"`
+	ComparisonNote string  `json:"comparisonNote"`
+}
+
+type AIAlert struct {
+	RuleName  string `json:"ruleName"`
+	Status    string `json:"status"`
+	Count     int    `json:"count"`
+	CreatedAt string `json:"createdAt"`
+}
+
+// CollectAISignals 采集一次分析所需的全部信号。
+func CollectAISignals(ctx context.Context, src *models.LogSource, userID uint, admin bool, from, to time.Time) (*AISignalBundle, error) {
+	if src == nil {
+		return nil, fmt.Errorf("数据源不存在")
+	}
+	if !to.After(from) {
+		return nil, fmt.Errorf("时间范围无效")
+	}
+	// 复用查询授权：AI 能看到的数据范围必须与当前用户一致，不多不少
+	selector, err := AuthorizedLogQuery(src, userID, admin, `{namespace=~".+"}`)
+	if err != nil {
+		return nil, err
+	}
+
+	bundle := &AISignalBundle{
+		SourceID:   src.ID,
+		SourceName: src.Name,
+		Selector:   selector,
+		// 时间统一按本地时区展示：Loki 返回的是 UTC，
+		// 直接给模型 UTC 会让结论里出现"凌晨 6 点"这种和用户作息对不上的时间。
+		From:         from.In(aiDisplayZone()).Format("2006-01-02 15:04"),
+		To:           to.In(aiDisplayZone()).Format("2006-01-02 15:04"),
+		RangeMinutes: int(to.Sub(from).Minutes()),
+		Alerts:       []AIAlert{},
+		Trend:        []AITrendPoint{},
+		Apps:         []AISignalApp{},
+	}
+
+	// ── 体积 + 趋势：volume_range（只读索引元数据）──
+	buckets, err := LokiHistogram(ctx, src, selector, from.UnixNano(), to.UnixNano())
+	if err != nil {
+		return nil, err
+	}
+	for _, b := range buckets {
+		var bytes int64
+		switch v := b["count"].(type) {
+		case int64:
+			bytes = v
+		case float64:
+			bytes = int64(v)
+		}
+		ts, _ := b["timestamp"].(string)
+		if parsed, perr := time.Parse(time.RFC3339, ts); perr == nil {
+			ts = parsed.In(aiDisplayZone()).Format("15:04")
+		}
+		bundle.TotalBytes += bytes
+		bundle.Trend = append(bundle.Trend, AITrendPoint{Time: ts, Bytes: bytes})
+	}
+	// 趋势只保留尾部若干桶，避免 prompt 过长
+	if len(bundle.Trend) > 24 {
+		bundle.Trend = bundle.Trend[len(bundle.Trend)-24:]
+	}
+
+	// ── 条数：仅短窗口走 index/stats（长窗口太慢，直接跳过并标注）──
+	if bundle.RangeMinutes <= 120 {
+		if st, statErr := LokiStatsCached(ctx, src, selector, from.UnixNano(), to.UnixNano()); statErr == nil {
+			bundle.TotalEntries = st.Entries
+			bundle.Streams = st.Streams
+			bundle.Chunks = st.Chunks
+			bundle.EntriesExact = true
+		} else {
+			bundle.Warnings = append(bundle.Warnings, "条数统计失败："+truncateStr(statErr.Error(), 120))
+		}
+	} else {
+		bundle.Warnings = append(bundle.Warnings, "时间范围超过 2 小时，条数为估算（跳过 index/stats：全天统计实测需 20 秒）")
+	}
+
+	// ── 应用排行：平台按小时预聚合快照 ──
+	if rows := GetAppRanking(src.ID, from, to, 10, "entries"); len(rows) > 0 {
+		var total int64
+		for _, r := range rows {
+			total += r.Entries
+		}
+		for _, r := range rows {
+			share := ""
+			if total > 0 {
+				share = fmt.Sprintf("%.1f%%", float64(r.Entries)/float64(total)*100)
+			}
+			bundle.Apps = append(bundle.Apps, AISignalApp{
+				App: r.App, Namespace: r.Namespace, Entries: r.Entries, Bytes: r.Bytes, Share: share,
+			})
+		}
+	}
+	hours, _ := AppVolumeCoverageInfo(src.ID)
+	bundle.SnapshotHours = hours
+	if len(bundle.Apps) == 0 {
+		bundle.Warnings = append(bundle.Warnings, "应用排行暂无数据：平台按小时预聚合还在积累（当前留存 0 小时）")
+	}
+
+	// ── 基线对比：与上一个等长窗口比 ──
+	prevFrom := from.Add(-to.Sub(from))
+	prevTo := from
+	if prevBuckets, perr := LokiHistogram(ctx, src, selector, prevFrom.UnixNano(), prevTo.UnixNano()); perr == nil {
+		var prevBytes int64
+		for _, b := range prevBuckets {
+			switch v := b["count"].(type) {
+			case int64:
+				prevBytes += v
+			case float64:
+				prevBytes += int64(v)
+			}
+		}
+		if prevBytes > 0 || bundle.TotalBytes > 0 {
+			delta := 0.0
+			if prevBytes > 0 {
+				delta = (float64(bundle.TotalBytes) - float64(prevBytes)) / float64(prevBytes) * 100
+			}
+			bundle.Baseline = &AIBaseline{
+				PreviousBytes:  prevBytes,
+				CurrentBytes:   bundle.TotalBytes,
+				DeltaPercent:   delta,
+				ComparisonNote: fmt.Sprintf("与上一个 %d 分钟等长窗口对比", bundle.RangeMinutes),
+			}
+		}
+	}
+
+	// ── 告警：窗口内的投递记录 ──
+	db := repository.GetDB()
+	if db != nil {
+		db.RLock()
+		for _, d := range db.AlertDeliveries {
+			if d.CreatedAt.Before(from) || d.CreatedAt.After(to) {
+				continue
+			}
+			bundle.Alerts = append(bundle.Alerts, AIAlert{
+				RuleName: d.RuleName, Status: d.Status, Count: d.Count,
+				CreatedAt: d.CreatedAt.In(aiDisplayZone()).Format("2006-01-02 15:04"),
+			})
+		}
+		db.RUnlock()
+	}
+	sort.Slice(bundle.Alerts, func(i, j int) bool { return bundle.Alerts[i].CreatedAt > bundle.Alerts[j].CreatedAt })
+	if len(bundle.Alerts) > 10 {
+		bundle.Alerts = bundle.Alerts[:10]
+	}
+	return bundle, nil
+}
+
+// SignalsAsText 把信号包渲染成给模型看的紧凑文本（不是 JSON，省 token）。
+func SignalsAsText(b *AISignalBundle) string {
+	var sb strings.Builder
+	fmt.Fprintf(&sb, "数据源：%s\n", b.SourceName)
+	fmt.Fprintf(&sb, "时间范围：%s ~ %s（%d 分钟）\n", b.From, b.To, b.RangeMinutes)
+	fmt.Fprintf(&sb, "日志体积：%.2f GB\n", float64(b.TotalBytes)/1024/1024/1024)
+	if b.EntriesExact {
+		fmt.Fprintf(&sb, "日志条数：%d\n", b.TotalEntries)
+	} else {
+		sb.WriteString("日志条数：（范围过大未精确统计）\n")
+	}
+	if b.Streams > 0 || b.Chunks > 0 {
+		fmt.Fprintf(&sb, "流数/块数：%d / %d\n", b.Streams, b.Chunks)
+	}
+	if b.Baseline != nil {
+		fmt.Fprintf(&sb, "基线对比：上一等长窗口 %.2f GB → 当前 %.2f GB，变化 %+.1f%%（%s）\n",
+			float64(b.Baseline.PreviousBytes)/1024/1024/1024,
+			float64(b.Baseline.CurrentBytes)/1024/1024/1024,
+			b.Baseline.DeltaPercent, b.Baseline.ComparisonNote)
+	}
+	if len(b.Apps) > 0 {
+		sb.WriteString("\n应用日志量排行（来自平台小时级预聚合）：\n")
+		for i, a := range b.Apps {
+			fmt.Fprintf(&sb, "  %d. %s/%s  条数=%d 占比=%s\n", i+1, a.Namespace, a.App, a.Entries, a.Share)
+		}
+	}
+	if len(b.Trend) > 0 {
+		sb.WriteString("\n体积趋势（最近分桶）：\n")
+		for _, t := range b.Trend {
+			fmt.Fprintf(&sb, "  %s  %.1f MB\n", t.Time, float64(t.Bytes)/1024/1024)
+		}
+	}
+	if len(b.Alerts) > 0 {
+		sb.WriteString("\n窗口内告警：\n")
+		for _, a := range b.Alerts {
+			fmt.Fprintf(&sb, "  %s  %s  命中=%d  状态=%s\n", a.CreatedAt, a.RuleName, a.Count, a.Status)
+		}
+	} else {
+		sb.WriteString("\n窗口内告警：无\n")
+	}
+	if len(b.Warnings) > 0 {
+		sb.WriteString("\n数据限制说明：\n")
+		for _, w := range b.Warnings {
+			fmt.Fprintf(&sb, "  - %s\n", w)
+		}
+	}
+	return sb.String()
+}