sundynix-agentix/sundynix-gateway/internal/store/model.go

package store

import (
	"context"
	"time"

	"gorm.io/gorm"
	"gorm.io/gorm/clause"
)

// KB 是一个知识库（按 owner 隔离 + 按 kind 组织：文件夹/项目/案件/通用）。
// 表名 sundynix_kb。(owner,name) 唯一 —— 同一用户下知识库名不重复。
// 向量/全文/图谱实际以 "owner/name" 作分区键，保证只有 owner 能查到自己的库。
type KB struct {
	ID        uint   `gorm:"primaryKey"`
	Owner     string `gorm:"size:64;uniqueIndex:idx_kb_owner_name"`
	Name      string `gorm:"size:64;uniqueIndex:idx_kb_owner_name"`
	Kind      string `gorm:"size:16"` // folder / project / case / general
	CreatedAt time.Time
}

func (KB) TableName() string { return "sundynix_kb" }

// ListKB 列出某 owner 的全部知识库（按创建时间）。
func (p *Postgres) ListKB(ctx context.Context, owner string) ([]KB, error) {
	if p.db == nil {
		return nil, nil
	}
	var rows []KB
	err := p.db.WithContext(ctx).Where("owner = ?", owner).Order("id").Find(&rows).Error
	return rows, err
}

// EnsureKB 幂等登记一个知识库（已存在则保持，不覆盖 kind）。
func (p *Postgres) EnsureKB(ctx context.Context, owner, name, kind string) error {
	if p.db == nil {
		return nil // 降级模式：不持久化注册表，不阻断入库
	}
	if kind == "" {
		kind = "general"
	}
	return p.db.WithContext(ctx).Clauses(clause.OnConflict{
		Columns:   []clause.Column{{Name: "owner"}, {Name: "name"}},
		DoNothing: true,
	}).Create(&KB{Owner: owner, Name: name, Kind: kind}).Error
}

// Doc 是入库的一份原始文档/笔记（供 Obsidian 式"文库"浏览：列表 + Markdown 阅读 + 双链）。
// 表名 sundynix_doc。(owner,kb,name) 唯一；按 owner 隔离。
type Doc struct {
	ID        uint   `gorm:"primaryKey"`
	Owner     string `gorm:"size:64;uniqueIndex:idx_doc_okn"`
	KB        string `gorm:"size:64;uniqueIndex:idx_doc_okn"`
	Name      string `gorm:"size:160;uniqueIndex:idx_doc_okn"`
	Content   string `gorm:"type:text"`
	CreatedAt time.Time
}

func (Doc) TableName() string { return "sundynix_doc" }

// SaveDoc 写入/更新一份文档（owner+kb+name 唯一，重名覆盖内容）。
func (p *Postgres) SaveDoc(ctx context.Context, owner, kb, name, content string) error {
	if p.db == nil {
		return nil
	}
	return p.db.WithContext(ctx).Clauses(clause.OnConflict{
		Columns:   []clause.Column{{Name: "owner"}, {Name: "kb"}, {Name: "name"}},
		DoUpdates: clause.AssignmentColumns([]string{"content"}),
	}).Create(&Doc{Owner: owner, KB: kb, Name: name, Content: content}).Error
}

// ListVault 返回某 owner 某 kb 的全部文档（名+内容），供文库浏览/双链/反链。
func (p *Postgres) ListVault(ctx context.Context, owner, kb string) ([]Doc, error) {
	if p.db == nil {
		return nil, nil
	}
	var rows []Doc
	err := p.db.WithContext(ctx).Where("owner = ? AND kb = ?", owner, kb).Order("id").Find(&rows).Error
	return rows, err
}

// LLMModel 是一个模型后端配置（控制面：管理员在此登记可用模型）。
// 表名 sundynix_model（遵守前缀约定）。每个 kind 同一时刻仅一条 Active=true。
type LLMModel struct {
	ID       uint   `gorm:"primaryKey"`
	Kind     string `gorm:"size:16;index"` // chat / embedding
	Provider string `gorm:"size:32"`       // openai-compatible / vllm
	BaseURL  string `gorm:"size:255"`      // 如 https://api.deepseek.com
	APIKey   string `gorm:"size:255"`
	Model    string `gorm:"size:64"` // 如 deepseek-chat / text-embedding-v3
	Active   bool
}

func (LLMModel) TableName() string { return "sundynix_model" }

// ListModels 列出某 kind 的模型配置（kind 空则全部）。
func (p *Postgres) ListModels(ctx context.Context, kind string) ([]LLMModel, error) {
	if p.db == nil {
		return nil, nil
	}
	var rows []LLMModel
	q := p.db.WithContext(ctx).Order("id")
	if kind != "" {
		q = q.Where("kind = ?", kind)
	}
	err := q.Find(&rows).Error
	return rows, err
}

// SaveModel 新增或更新一条模型配置（ID==0 新增）。
func (p *Postgres) SaveModel(ctx context.Context, m *LLMModel) error {
	if p.db == nil {
		return errStoreDisabled
	}
	return p.db.WithContext(ctx).Save(m).Error
}

// SetActiveModel 把指定模型设为激活（同 kind 内其余取消），事务保证每 kind 唯一激活。
func (p *Postgres) SetActiveModel(ctx context.Context, id uint) error {
	if p.db == nil {
		return errStoreDisabled
	}
	return p.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
		var m LLMModel
		if err := tx.First(&m, id).Error; err != nil {
			return err
		}
		if err := tx.Model(&LLMModel{}).Where("kind = ? AND active = ?", m.Kind, true).Update("active", false).Error; err != nil {
			return err
		}
		return tx.Model(&LLMModel{}).Where("id = ?", id).Update("active", true).Error
	})
}

// GetActiveModel 返回某 kind 当前激活模型（无则 nil）。
func (p *Postgres) GetActiveModel(ctx context.Context, kind string) (*LLMModel, error) {
	if p.db == nil {
		return nil, nil
	}
	var m LLMModel
	err := p.db.WithContext(ctx).Where("kind = ? AND active = ?", kind, true).First(&m).Error
	if err != nil {
		return nil, nil // 未配置激活模型
	}
	return &m, nil
}

// DeleteModel 删除一条模型配置。
func (p *Postgres) DeleteModel(ctx context.Context, id uint) error {
	if p.db == nil {
		return errStoreDisabled
	}
	return p.db.WithContext(ctx).Delete(&LLMModel{}, id).Error
}