chore: 恢复旧布局基线(迁移改动丢失后重建,apps/packages 布局暂存)

This commit is contained in:
logan committed 2026-10-14 20:31:17 +08:00
1 parent a9510235bb
commit 456fa6954b
203 files changed
+18787 -48

No files matched your search

+89
View File
@@ -0,0 +1,89 @@
package ai
import (
"encoding/json"
"os"
"path/filepath"
"strings"
)
// Config AI 配置;provider: stub|openai(OpenAI 兼容协议)。
type Config struct {
Provider string `json:"provider"`
BaseURL string `json:"baseURL"`
APIKey string `json:"apiKey,omitempty"`
Model string `json:"model"`
}
func configPath() (string, error) {
home, err := os.UserHomeDir()
if err != nil {
return "", err
}
return filepath.Join(home, ".opsxdb", "ai.json"), nil
}
// LoadConfig 读取配置:~/.opsxdb/ai.json 优先,env(OPSXDB_AI_*)兜底逐字段补充。
func LoadConfig() Config {
cfg := Config{
Provider: strings.TrimSpace(os.Getenv("OPSXDB_AI_PROVIDER")),
BaseURL: strings.TrimSpace(os.Getenv("OPSXDB_AI_BASE_URL")),
APIKey: strings.TrimSpace(os.Getenv("OPSXDB_AI_API_KEY")),
Model: strings.TrimSpace(os.Getenv("OPSXDB_AI_MODEL")),
}
if p, err := configPath(); err == nil {
if b, err := os.ReadFile(p); err == nil {
var f Config
if json.Unmarshal(b, &f) == nil {
if f.Provider != "" {
cfg.Provider = f.Provider
}
if f.BaseURL != "" {
cfg.BaseURL = f.BaseURL
}
if f.APIKey != "" {
cfg.APIKey = f.APIKey
}
if f.Model != "" {
cfg.Model = f.Model
}
}
}
}
if cfg.Provider == "" {
if cfg.APIKey != "" {
cfg.Provider = "openai"
} else {
cfg.Provider = "stub"
}
}
return cfg
}
// SaveConfig 写 ~/.opsxdb/ai.json(0600,与本机 token 同威胁模型)。
func SaveConfig(c Config) error {
p, err := configPath()
if err != nil {
return err
}
if err := os.MkdirAll(filepath.Dir(p), 0700); err != nil {
return err
}
b, err := json.MarshalIndent(c, "", " ")
if err != nil {
return err
}
return os.WriteFile(p, b, 0600)
}
// MaskedKey 返回脱敏后的 key 展示形式(sk-***)。
func (c Config) MaskedKey() string {
k := c.APIKey
if k == "" {
return ""
}
if len(k) <= 6 {
return "***"
}
return k[:3] + "***"
}
+117
View File
@@ -0,0 +1,117 @@
package ai
import (
"bytes"
"context"
"encoding/json"
"fmt"
"io"
"net/http"
"regexp"
"strings"
"time"
)
const (
defaultOpenAIBaseURL = "https://api.openai.com/v1"
defaultOpenAIModel = "gpt-4o-mini"
)
// OpenAIProvider OpenAI 兼容协议实现(DeepSeek/通义/本地 vLLM 同协议可用)。
type OpenAIProvider struct {
baseURL string
apiKey string
model string
hc *http.Client
}
func NewOpenAIProvider(cfg Config) *OpenAIProvider {
base := strings.TrimRight(strings.TrimSpace(cfg.BaseURL), "/")
if base == "" {
base = defaultOpenAIBaseURL
}
model := strings.TrimSpace(cfg.Model)
if model == "" {
model = defaultOpenAIModel
}
return &OpenAIProvider{
baseURL: base,
apiKey: cfg.APIKey,
model: model,
hc: &http.Client{Timeout: 60 * time.Second},
}
}
func (p *OpenAIProvider) Name() string { return "openai" }
type chatCompletionReq struct {
Model string `json:"model"`
Messages []Message `json:"messages"`
}
type chatCompletionRes struct {
Choices []struct {
Message Message `json:"message"`
} `json:"choices"`
Error *struct {
Message string `json:"message"`
} `json:"error"`
}
// Complete 单次非流式调用;ctx 全透传,HTTP 层 60s 超时兜底。
func (p *OpenAIProvider) Complete(ctx context.Context, req ChatReq) (ChatRes, error) {
model := p.model
if strings.TrimSpace(req.Model) != "" {
model = strings.TrimSpace(req.Model)
}
payload := chatCompletionReq{
Model: model,
Messages: BuildMessages(req),
}
body, err := json.Marshal(payload)
if err != nil {
return ChatRes{}, err
}
httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, p.baseURL+"/chat/completions", bytes.NewReader(body))
if err != nil {
return ChatRes{}, err
}
httpReq.Header.Set("Content-Type", "application/json")
httpReq.Header.Set("Authorization", "Bearer "+p.apiKey)
resp, err := p.hc.Do(httpReq)
if err != nil {
return ChatRes{}, fmt.Errorf("AI 请求失败: %w", err)
}
defer resp.Body.Close()
raw, err := io.ReadAll(io.LimitReader(resp.Body, 4<<20))
if err != nil {
return ChatRes{}, fmt.Errorf("读取 AI 响应失败: %w", err)
}
var out chatCompletionRes
if err := json.Unmarshal(raw, &out); err != nil {
return ChatRes{}, fmt.Errorf("解析 AI 响应失败(HTTP %d)", resp.StatusCode)
}
if out.Error != nil {
return ChatRes{}, fmt.Errorf("AI 服务返回错误: %s", out.Error.Message)
}
if resp.StatusCode != http.StatusOK {
return ChatRes{}, fmt.Errorf("AI 服务 HTTP %d", resp.StatusCode)
}
if len(out.Choices) == 0 {
return ChatRes{}, fmt.Errorf("AI 服务未返回候选结果")
}
content := strings.TrimSpace(out.Choices[0].Message.Content)
return ChatRes{Content: content, SQL: extractSQL(content)}, nil
}
var sqlFence = regexp.MustCompile("(?s)```sql\\s*\n(.+?)```")
// extractSQL 从模型回复中提取 ```sql 代码块内容。
func extractSQL(content string) string {
m := sqlFence.FindStringSubmatch(content)
if len(m) < 2 {
return ""
}
return strings.TrimSpace(m[1])
}
+72
View File
@@ -0,0 +1,72 @@
package ai
import (
"fmt"
"strings"
)
// schemaContextCap 注入给模型的库表结构上下文长度上限。
const schemaContextCap = 4000
// BuildMessages 按 action 选 system 模板装配对话;req.Schema 非空时注入库表列上下文。
func BuildMessages(req ChatReq) []Message {
driver := req.Driver
if driver == "" {
driver = "mysql"
}
sys := "你是资深数据库工程师助手,服务于数据库客户端 OpsxDB。回答使用中文,SQL 代码放在 ```sql 代码块中。"
var task string
switch strings.ToLower(req.Action) {
case "generate", "ask":
task = fmt.Sprintf("根据用户描述生成一条 %s 方言的 SQL。只输出可执行 SQL 与极简说明。", driver)
case "explain":
task = "逐部分解释用户给出的 SQL:访问路径、索引使用、潜在代价。"
case "optimize":
task = "审查用户给出的 SQL 并给出优化版本:索引建议、重写建议、说明理由。"
case "fix":
task = "根据报错信息修复用户给出的 SQL,指出错误原因并给出修正后的完整 SQL。"
case "dialect":
task = fmt.Sprintf("把用户给出的 SQL 转换为 %s 方言,保持语义一致。", driver)
case "sample":
task = "为当前库生成一条有代表性的示例查询 SQL。"
default:
task = "回答用户关于数据库 / SQL 的问题。"
}
var sb strings.Builder
sb.WriteString(sys)
sb.WriteString("\n")
sb.WriteString(task)
if req.Database != "" {
sb.WriteString(fmt.Sprintf("\n当前数据库: %s(%s)", req.Database, driver))
}
if s := strings.TrimSpace(req.Schema); s != "" {
if len(s) > schemaContextCap {
s = s[:schemaContextCap]
}
sb.WriteString("\n当前数据库结构:\n")
sb.WriteString(s)
}
var user strings.Builder
if p := strings.TrimSpace(req.Prompt); p != "" {
user.WriteString(p)
}
if s := strings.TrimSpace(req.SQL); s != "" {
if user.Len() > 0 {
user.WriteString("\n\n")
}
user.WriteString("SQL:\n")
user.WriteString(s)
}
if e := strings.TrimSpace(req.Error); e != "" {
user.WriteString("\n\n报错:\n")
user.WriteString(e)
}
if user.Len() == 0 {
user.WriteString("你好")
}
return []Message{
{Role: "system", Content: sb.String()},
{Role: "user", Content: user.String()},
}
}
+45
View File
@@ -0,0 +1,45 @@
package ai
import "context"
// Message 对话消息(OpenAI 兼容协议)。
type Message struct {
Role string `json:"role"`
Content string `json:"content"`
}
// ChatReq 在 stub 时代字段上演进,前端契约不变;新增 schema/model 可选字段。
type ChatReq struct {
Action string `json:"action"`
Prompt string `json:"prompt"`
SQL string `json:"sql"`
Driver string `json:"driver"`
Database string `json:"database"`
Error string `json:"error"`
Schema string `json:"schema,omitempty"` // 前端注入的库表列上下文
Model string `json:"model,omitempty"`
}
type ChatRes struct {
Content string `json:"content"`
SQL string `json:"sql,omitempty"`
}
// Provider AI 提供方抽象。本轮只做非流式 Complete;
// Stream(ctx, req) (<-chan string, error) 预留,SSE 流式留待后续版本。
type Provider interface {
Name() string
Complete(ctx context.Context, req ChatReq) (ChatRes, error)
}
// Default 按当前配置选择 Provider;未配置 API Key 时回落 stub(离线占位)。
func Default() Provider {
cfg := LoadConfig()
switch cfg.Provider {
case "openai":
if cfg.APIKey != "" {
return NewOpenAIProvider(cfg)
}
}
return stubProvider{}
}
+93
View File
@@ -0,0 +1,93 @@
package ai
import (
"context"
"fmt"
"strings"
)
// stubProvider 离线占位实现:未配置真实模型时的兜底,内容为字符串模板。
type stubProvider struct{}
func (stubProvider) Name() string { return "stub" }
func (stubProvider) Complete(_ context.Context, req ChatReq) (ChatRes, error) {
return chatStub(req), nil
}
func chatStub(req ChatReq) ChatRes {
driver := req.Driver
if driver == "" {
driver = "mysql"
}
db := req.Database
if db == "" {
db = "your_db"
}
sql := strings.TrimSpace(req.SQL)
prompt := strings.TrimSpace(req.Prompt)
switch strings.ToLower(req.Action) {
case "generate", "ask":
q := prompt
if q == "" {
q = "示例查询"
}
gen := fmt.Sprintf("-- 根据描述生成(%s / %s)\n-- 需求: %s\nSELECT *\nFROM `%s`.some_table\nWHERE 1=1\nLIMIT 100;", driver, db, q, db)
return ChatRes{
Content: fmt.Sprintf("已根据「%s」生成 SQL(stub,可替换为真实模型)。\n\n```sql\n%s\n```", q, gen),
SQL: gen,
}
case "explain":
if sql == "" {
sql = "SELECT 1"
}
return ChatRes{Content: fmt.Sprintf("## 解释 SQL\n\n```sql\n%s\n```\n\n- 这是一条在 **%s** 上执行的查询。\n- 建议检查 WHERE 条件是否走索引,避免 `SELECT *` 拉取过大结果集。\n- (stub 回复)", sql, driver)}
case "optimize":
opt := sql
if opt == "" {
opt = "SELECT id, name FROM users WHERE status = 1 LIMIT 100;"
} else if strings.Contains(strings.ToUpper(opt), "SELECT *") {
opt = strings.Replace(opt, "*", "id /* TODO: 显式列 */", 1)
}
opt = strings.TrimSpace(opt)
if !strings.Contains(strings.ToUpper(opt), "LIMIT") {
opt = opt + "\nLIMIT 100;"
}
return ChatRes{
Content: fmt.Sprintf("## 优化建议\n\n1. 避免不必要的全表扫描\n2. 显式列出列名\n3. 加合理 LIMIT\n\n```sql\n%s\n```", opt),
SQL: opt,
}
case "fix":
fixed := sql
if fixed == "" {
fixed = "SELECT 1 AS ok;"
}
msg := req.Error
if msg == "" {
msg = "未知错误"
}
return ChatRes{
Content: fmt.Sprintf("## 修复错误\n\n原错误:`%s`\n\n尝试修正后的 SQL:\n\n```sql\n%s\n```\n\n(stub:请结合真实报错继续调整)", msg, fixed),
SQL: fixed,
}
case "dialect":
out := sql
if out == "" {
out = "SELECT * FROM dual"
}
out = strings.ReplaceAll(out, "`", "\"")
return ChatRes{
Content: fmt.Sprintf("## 方言转换 → PostgreSQL 风格(示例)\n\n```sql\n%s\n```", out),
SQL: out,
}
case "sample":
sample := fmt.Sprintf("SELECT id, name, created_at\nFROM `%s`.users\nORDER BY id DESC\nLIMIT 20;", db)
return ChatRes{
Content: fmt.Sprintf("## 样例 SQL(%s)\n\n```sql\n%s\n```", driver, sample),
SQL: sample,
}
default:
return ChatRes{Content: "未知 AI 动作。可用:ask / generate / explain / optimize / fix / dialect / sample"}
}
}