3b6fca44a6
后端：
1.阶段 6 CP4/CP5 目录收口与共享边界纯化
- 将 backend 根目录收口为 services、client、gateway、cmd、shared 五个一级目录
- 收拢 bootstrap、inits、infra/kafka、infra/outbox、conv、respond、pkg、middleware，移除根目录旧实现与空目录
- 将 utils 下沉到 services/userauth/internal/auth，将 logic 下沉到 services/schedule/core/planning
- 将迁移期 runtime 桥接实现统一收拢到 services/runtime/{conv,dao,eventsvc,model}，删除 shared/legacy 与未再被 import 的旧 service 实现
- 将 gateway/shared/respond 收口为 HTTP/Gin 错误写回适配，shared/respond 仅保留共享错误语义与状态映射
- 将 HTTP IdempotencyMiddleware 与 RateLimitMiddleware 收口到 gateway/middleware
- 将 GormCachePlugin 下沉到 shared/infra/gormcache，将共享 RateLimiter 下沉到 shared/infra/ratelimit，将 agent token budget 下沉到 services/agent/shared
- 删除 InitEino 兼容壳，收缩 cmd/internal/coreinit 仅保留旧组合壳残留域初始化语义
- 更新微服务迁移计划与桌面 checklist，补齐 CP4/CP5 当前切流点、目录终态与验证结果
- 完成 go test ./...、git diff --check 与最终真实 smoke；health、register/login、task/create+get、schedule/today、task-class/list、memory/items、agent chat/meta/timeline/context-stats 全部 200，SSE 合并结果为 CP5_OK 且 [DONE] 只有 1 个
660 lines
19 KiB
Go
660 lines
19 KiB
Go
package service
|
||
|
||
import (
|
||
"context"
|
||
"errors"
|
||
"strings"
|
||
"time"
|
||
|
||
memoryrepo "github.com/LoveLosita/smartflow/backend/services/memory/internal/repo"
|
||
memoryutils "github.com/LoveLosita/smartflow/backend/services/memory/internal/utils"
|
||
memoryvectorsync "github.com/LoveLosita/smartflow/backend/services/memory/internal/vectorsync"
|
||
memorymodel "github.com/LoveLosita/smartflow/backend/services/memory/model"
|
||
memoryobserve "github.com/LoveLosita/smartflow/backend/services/memory/observe"
|
||
"github.com/LoveLosita/smartflow/backend/services/runtime/model"
|
||
"github.com/LoveLosita/smartflow/backend/shared/respond"
|
||
"gorm.io/gorm"
|
||
)
|
||
|
||
const (
|
||
defaultManageListLimit = 20
|
||
maxManageListLimit = 100
|
||
defaultManualConfidence = 0.95
|
||
defaultManualImportance = 0.90
|
||
)
|
||
|
||
// ManageService 负责 memory 模块内部的管理面能力。
|
||
//
|
||
// 职责边界：
|
||
// 1. 负责“列出记忆 / 删除记忆 / 读取与更新用户开关”这类维护动作；
|
||
// 2. 负责把用户主动管理行为补充进 memory_audit_logs；
|
||
// 3. 不负责 prompt 注入、不负责向量召回，也不负责后台抽取任务执行。
|
||
type ManageService struct {
|
||
db *gorm.DB
|
||
itemRepo *memoryrepo.ItemRepo
|
||
auditRepo *memoryrepo.AuditRepo
|
||
settingsRepo *memoryrepo.SettingsRepo
|
||
vectorSyncer *memoryvectorsync.Syncer
|
||
observer memoryobserve.Observer
|
||
metrics memoryobserve.MetricsRecorder
|
||
}
|
||
|
||
func NewManageService(
|
||
db *gorm.DB,
|
||
itemRepo *memoryrepo.ItemRepo,
|
||
auditRepo *memoryrepo.AuditRepo,
|
||
settingsRepo *memoryrepo.SettingsRepo,
|
||
vectorSyncer *memoryvectorsync.Syncer,
|
||
observer memoryobserve.Observer,
|
||
metrics memoryobserve.MetricsRecorder,
|
||
) *ManageService {
|
||
if observer == nil {
|
||
observer = memoryobserve.NewNopObserver()
|
||
}
|
||
if metrics == nil {
|
||
metrics = memoryobserve.NewNopMetrics()
|
||
}
|
||
return &ManageService{
|
||
db: db,
|
||
itemRepo: itemRepo,
|
||
auditRepo: auditRepo,
|
||
settingsRepo: settingsRepo,
|
||
vectorSyncer: vectorSyncer,
|
||
observer: observer,
|
||
metrics: metrics,
|
||
}
|
||
}
|
||
|
||
// ListItems 列出某个用户当前可管理的记忆条目。
|
||
//
|
||
// 说明：
|
||
// 1. 这里面向“管理视角”，不会按用户开关再做二次过滤；
|
||
// 2. 即便用户暂时关闭 memory，总览页仍需要看见已有记忆，便于手动删除或核对；
|
||
// 3. 默认只返回 active/archived，除非显式传入 deleted。
|
||
func (s *ManageService) ListItems(ctx context.Context, req memorymodel.ListItemsRequest) ([]memorymodel.ItemDTO, error) {
|
||
if s == nil || s.itemRepo == nil {
|
||
return nil, errors.New("memory manage service is nil")
|
||
}
|
||
if req.UserID <= 0 {
|
||
return nil, nil
|
||
}
|
||
|
||
conversationID := strings.TrimSpace(req.ConversationID)
|
||
query := memorymodel.ItemQuery{
|
||
UserID: req.UserID,
|
||
ConversationID: conversationID,
|
||
Statuses: normalizeManageStatuses(req.Statuses),
|
||
MemoryTypes: normalizeMemoryTypes(req.MemoryTypes),
|
||
IncludeGlobal: conversationID != "",
|
||
OnlyUnexpired: false,
|
||
Limit: normalizeLimit(req.Limit, defaultManageListLimit, maxManageListLimit),
|
||
}
|
||
|
||
items, err := s.itemRepo.FindByQuery(ctx, query)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return toItemDTOs(items), nil
|
||
}
|
||
|
||
// GetItem 返回“当前用户自己的某条记忆”详情。
|
||
func (s *ManageService) GetItem(ctx context.Context, req model.MemoryGetItemRequest) (*memorymodel.ItemDTO, error) {
|
||
if s == nil || s.itemRepo == nil {
|
||
return nil, errors.New("memory manage service is nil")
|
||
}
|
||
if req.UserID <= 0 {
|
||
return nil, respond.WrongUserID
|
||
}
|
||
if req.MemoryID <= 0 {
|
||
return nil, respond.WrongParamType
|
||
}
|
||
|
||
item, err := s.itemRepo.GetByIDForUser(ctx, req.UserID, req.MemoryID)
|
||
if err != nil {
|
||
return nil, translateManageError(err)
|
||
}
|
||
dto := toItemDTO(*item)
|
||
return &dto, nil
|
||
}
|
||
|
||
// CreateItem 手动新增一条用户记忆，并补审计与向量同步桥接。
|
||
func (s *ManageService) CreateItem(ctx context.Context, req model.MemoryCreateItemRequest) (*memorymodel.ItemDTO, error) {
|
||
if s == nil || s.db == nil || s.itemRepo == nil || s.auditRepo == nil {
|
||
return nil, errors.New("memory manage service is not initialized")
|
||
}
|
||
if req.UserID <= 0 {
|
||
return nil, respond.WrongUserID
|
||
}
|
||
|
||
fields, err := buildCreateItemFields(req)
|
||
if err != nil {
|
||
s.recordManageAction(ctx, "create", req.UserID, 0, fields.MemoryType, false, err)
|
||
return nil, err
|
||
}
|
||
|
||
var createdItem model.MemoryItem
|
||
err = s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
||
itemRepo := s.itemRepo.WithTx(tx)
|
||
auditRepo := s.auditRepo.WithTx(tx)
|
||
|
||
created, createErr := itemRepo.Create(ctx, fields)
|
||
if createErr != nil {
|
||
return createErr
|
||
}
|
||
createdItem = *created
|
||
|
||
audit := memoryutils.BuildItemAuditLog(
|
||
createdItem.ID,
|
||
createdItem.UserID,
|
||
memoryutils.AuditOperationCreate,
|
||
memoryutils.NormalizeOperatorType(req.OperatorType),
|
||
normalizeManageReason(req.Reason, "用户手动新增记忆"),
|
||
nil,
|
||
&createdItem,
|
||
)
|
||
return auditRepo.Create(ctx, audit)
|
||
})
|
||
if err != nil {
|
||
err = translateManageError(err)
|
||
s.recordManageAction(ctx, "create", req.UserID, 0, fields.MemoryType, false, err)
|
||
return nil, err
|
||
}
|
||
|
||
s.vectorSyncer.Upsert(ctx, "", []model.MemoryItem{createdItem})
|
||
s.recordManageAction(ctx, "create", req.UserID, createdItem.ID, createdItem.MemoryType, true, nil)
|
||
dto := toItemDTO(createdItem)
|
||
return &dto, nil
|
||
}
|
||
|
||
// UpdateItem 手动修改一条用户记忆，并补审计与向量重同步桥接。
|
||
func (s *ManageService) UpdateItem(ctx context.Context, req model.MemoryUpdateItemRequest) (*memorymodel.ItemDTO, error) {
|
||
if s == nil || s.db == nil || s.itemRepo == nil || s.auditRepo == nil {
|
||
return nil, errors.New("memory manage service is not initialized")
|
||
}
|
||
if req.UserID <= 0 {
|
||
return nil, respond.WrongUserID
|
||
}
|
||
if req.MemoryID <= 0 {
|
||
return nil, respond.WrongParamType
|
||
}
|
||
|
||
var updatedItem model.MemoryItem
|
||
err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
||
itemRepo := s.itemRepo.WithTx(tx)
|
||
auditRepo := s.auditRepo.WithTx(tx)
|
||
|
||
current, getErr := itemRepo.GetByIDForUser(ctx, req.UserID, req.MemoryID)
|
||
if getErr != nil {
|
||
return getErr
|
||
}
|
||
|
||
fields, afterItem, buildErr := buildUpdateItemFields(req, *current)
|
||
if buildErr != nil {
|
||
return buildErr
|
||
}
|
||
now := time.Now()
|
||
afterItem.UpdatedAt = &now
|
||
afterItem.VectorStatus = "pending"
|
||
|
||
if updateErr := itemRepo.UpdateManagedFieldsByIDAt(ctx, req.UserID, req.MemoryID, fields, now); updateErr != nil {
|
||
return updateErr
|
||
}
|
||
|
||
audit := memoryutils.BuildItemAuditLog(
|
||
current.ID,
|
||
current.UserID,
|
||
memoryutils.AuditOperationUpdate,
|
||
memoryutils.NormalizeOperatorType(req.OperatorType),
|
||
normalizeManageReason(req.Reason, "用户手动修改记忆"),
|
||
current,
|
||
&afterItem,
|
||
)
|
||
if auditErr := auditRepo.Create(ctx, audit); auditErr != nil {
|
||
return auditErr
|
||
}
|
||
|
||
updatedItem = afterItem
|
||
return nil
|
||
})
|
||
if err != nil {
|
||
err = translateManageError(err)
|
||
s.recordManageAction(ctx, "update", req.UserID, req.MemoryID, resolveUpdateMemoryType(req), false, err)
|
||
return nil, err
|
||
}
|
||
|
||
s.vectorSyncer.Upsert(ctx, "", []model.MemoryItem{updatedItem})
|
||
s.recordManageAction(ctx, "update", req.UserID, updatedItem.ID, updatedItem.MemoryType, true, nil)
|
||
dto := toItemDTO(updatedItem)
|
||
return &dto, nil
|
||
}
|
||
|
||
// DeleteItem 软删除一条记忆，并补写审计日志。
|
||
//
|
||
// 步骤化说明：
|
||
// 1. 先在事务里读取当前条目快照，确保审计前镜像和实际删除对象一致；
|
||
// 2. 若该条目已是 deleted，则直接按幂等语义返回，避免重复写多条删除审计；
|
||
// 3. 状态更新成功后再写 audit log，保证“有删除就有审计”，失败时整笔事务回滚。
|
||
func (s *ManageService) DeleteItem(ctx context.Context, req model.MemoryDeleteItemRequest) (*memorymodel.ItemDTO, error) {
|
||
if s == nil || s.db == nil || s.itemRepo == nil || s.auditRepo == nil {
|
||
return nil, errors.New("memory manage service is not initialized")
|
||
}
|
||
if req.UserID <= 0 {
|
||
return nil, respond.WrongUserID
|
||
}
|
||
if req.MemoryID <= 0 {
|
||
return nil, respond.WrongParamType
|
||
}
|
||
|
||
now := time.Now()
|
||
operatorType := memoryutils.NormalizeOperatorType(req.OperatorType)
|
||
reason := normalizeDeleteReason(req.Reason)
|
||
|
||
var deletedItem model.MemoryItem
|
||
err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
||
itemRepo := s.itemRepo.WithTx(tx)
|
||
auditRepo := s.auditRepo.WithTx(tx)
|
||
|
||
current, err := itemRepo.GetByIDForUser(ctx, req.UserID, req.MemoryID)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if current.Status == model.MemoryItemStatusDeleted {
|
||
deletedItem = *current
|
||
return nil
|
||
}
|
||
|
||
before := *current
|
||
after := before
|
||
after.Status = model.MemoryItemStatusDeleted
|
||
after.UpdatedAt = &now
|
||
after.VectorStatus = "pending"
|
||
|
||
if err = itemRepo.SoftDeleteByID(ctx, req.UserID, req.MemoryID); err != nil {
|
||
return err
|
||
}
|
||
|
||
audit := memoryutils.BuildItemAuditLog(
|
||
req.MemoryID,
|
||
req.UserID,
|
||
memoryutils.AuditOperationDelete,
|
||
operatorType,
|
||
reason,
|
||
&before,
|
||
&after,
|
||
)
|
||
if err = auditRepo.Create(ctx, audit); err != nil {
|
||
return err
|
||
}
|
||
|
||
deletedItem = after
|
||
return nil
|
||
})
|
||
if err != nil {
|
||
err = translateManageError(err)
|
||
s.recordManageAction(ctx, "delete", req.UserID, req.MemoryID, "", false, err)
|
||
return nil, err
|
||
}
|
||
if deletedItem.ID <= 0 {
|
||
return nil, nil
|
||
}
|
||
|
||
if deletedItem.Status == model.MemoryItemStatusDeleted {
|
||
s.vectorSyncer.Delete(ctx, "", []int64{deletedItem.ID})
|
||
}
|
||
s.recordManageAction(ctx, "delete", req.UserID, deletedItem.ID, deletedItem.MemoryType, true, nil)
|
||
result := toItemDTO(deletedItem)
|
||
return &result, nil
|
||
}
|
||
|
||
// RestoreItem 把 archived/deleted 记忆恢复为 active，并补审计与向量同步桥接。
|
||
func (s *ManageService) RestoreItem(ctx context.Context, req model.MemoryRestoreItemRequest) (*memorymodel.ItemDTO, error) {
|
||
if s == nil || s.db == nil || s.itemRepo == nil || s.auditRepo == nil {
|
||
return nil, errors.New("memory manage service is not initialized")
|
||
}
|
||
if req.UserID <= 0 {
|
||
return nil, respond.WrongUserID
|
||
}
|
||
if req.MemoryID <= 0 {
|
||
return nil, respond.WrongParamType
|
||
}
|
||
|
||
var restoredItem model.MemoryItem
|
||
err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
||
itemRepo := s.itemRepo.WithTx(tx)
|
||
auditRepo := s.auditRepo.WithTx(tx)
|
||
|
||
current, getErr := itemRepo.GetByIDForUser(ctx, req.UserID, req.MemoryID)
|
||
if getErr != nil {
|
||
return getErr
|
||
}
|
||
if current.Status == model.MemoryItemStatusActive {
|
||
restoredItem = *current
|
||
return nil
|
||
}
|
||
|
||
now := time.Now()
|
||
before := *current
|
||
after := before
|
||
after.Status = model.MemoryItemStatusActive
|
||
after.UpdatedAt = &now
|
||
after.VectorStatus = "pending"
|
||
|
||
if restoreErr := itemRepo.RestoreByIDAt(ctx, req.UserID, req.MemoryID, now); restoreErr != nil {
|
||
return restoreErr
|
||
}
|
||
|
||
audit := memoryutils.BuildItemAuditLog(
|
||
before.ID,
|
||
before.UserID,
|
||
memoryutils.AuditOperationRestore,
|
||
memoryutils.NormalizeOperatorType(req.OperatorType),
|
||
normalizeManageReason(req.Reason, "用户恢复记忆"),
|
||
&before,
|
||
&after,
|
||
)
|
||
if auditErr := auditRepo.Create(ctx, audit); auditErr != nil {
|
||
return auditErr
|
||
}
|
||
|
||
restoredItem = after
|
||
return nil
|
||
})
|
||
if err != nil {
|
||
err = translateManageError(err)
|
||
s.recordManageAction(ctx, "restore", req.UserID, req.MemoryID, "", false, err)
|
||
return nil, err
|
||
}
|
||
|
||
s.vectorSyncer.Upsert(ctx, "", []model.MemoryItem{restoredItem})
|
||
s.recordManageAction(ctx, "restore", req.UserID, restoredItem.ID, restoredItem.MemoryType, true, nil)
|
||
dto := toItemDTO(restoredItem)
|
||
return &dto, nil
|
||
}
|
||
|
||
// GetUserSetting 返回用户当前生效的记忆开关。
|
||
//
|
||
// 返回语义：
|
||
// 1. 若数据库中还没有记录，返回系统默认开关，而不是 nil；
|
||
// 2. 这样前端/上层调用方始终拿到完整结构，避免再做一层判空补默认值；
|
||
// 3. 这里只读 settings，不附带修改动作。
|
||
func (s *ManageService) GetUserSetting(ctx context.Context, userID int) (memorymodel.UserSettingDTO, error) {
|
||
if s == nil || s.settingsRepo == nil {
|
||
return memorymodel.UserSettingDTO{}, errors.New("memory manage service is nil")
|
||
}
|
||
if userID <= 0 {
|
||
return memorymodel.UserSettingDTO{}, nil
|
||
}
|
||
|
||
setting, err := s.settingsRepo.GetByUserID(ctx, userID)
|
||
if err != nil {
|
||
return memorymodel.UserSettingDTO{}, err
|
||
}
|
||
return toUserSettingDTO(memoryutils.EffectiveUserSetting(setting, userID)), nil
|
||
}
|
||
|
||
// UpsertUserSetting 写入用户记忆开关。
|
||
//
|
||
// 说明：
|
||
// 1. 当前阶段先直接覆盖三类开关，不做 patch 语义；
|
||
// 2. 这样便于前端把整块设置表单一次性提交，接口语义更稳定；
|
||
// 3. 若后续需要记录设置变更审计，再单独扩展 setting audit，而不是复用 item audit。
|
||
func (s *ManageService) UpsertUserSetting(ctx context.Context, req memorymodel.UpdateUserSettingRequest) (memorymodel.UserSettingDTO, error) {
|
||
if s == nil || s.settingsRepo == nil {
|
||
return memorymodel.UserSettingDTO{}, errors.New("memory manage service is nil")
|
||
}
|
||
if req.UserID <= 0 {
|
||
return memorymodel.UserSettingDTO{}, nil
|
||
}
|
||
|
||
now := time.Now()
|
||
setting := model.MemoryUserSetting{
|
||
UserID: req.UserID,
|
||
MemoryEnabled: req.MemoryEnabled,
|
||
ImplicitMemoryEnabled: req.ImplicitMemoryEnabled,
|
||
SensitiveMemoryEnabled: req.SensitiveMemoryEnabled,
|
||
UpdatedAt: &now,
|
||
}
|
||
if err := s.settingsRepo.Upsert(ctx, setting); err != nil {
|
||
return memorymodel.UserSettingDTO{}, err
|
||
}
|
||
return toUserSettingDTO(setting), nil
|
||
}
|
||
|
||
func normalizeDeleteReason(reason string) string {
|
||
reason = strings.TrimSpace(reason)
|
||
if reason == "" {
|
||
return "用户删除记忆"
|
||
}
|
||
return reason
|
||
}
|
||
|
||
func normalizeManageReason(reason string, fallback string) string {
|
||
reason = strings.TrimSpace(reason)
|
||
if reason == "" {
|
||
return fallback
|
||
}
|
||
return reason
|
||
}
|
||
|
||
func translateManageError(err error) error {
|
||
switch {
|
||
case err == nil:
|
||
return nil
|
||
case errors.Is(err, gorm.ErrRecordNotFound):
|
||
return respond.MemoryItemNotFound
|
||
default:
|
||
return err
|
||
}
|
||
}
|
||
|
||
func buildCreateItemFields(req model.MemoryCreateItemRequest) (memorymodel.CreateItemFields, error) {
|
||
memoryType, err := normalizeManagedMemoryType(req.MemoryType)
|
||
if err != nil {
|
||
return memorymodel.CreateItemFields{}, err
|
||
}
|
||
content, normalizedContent, err := normalizeManagedContent(req.Content)
|
||
if err != nil {
|
||
return memorymodel.CreateItemFields{}, err
|
||
}
|
||
|
||
title := normalizeManagedTitle(req.Title, content)
|
||
return memorymodel.CreateItemFields{
|
||
UserID: req.UserID,
|
||
ConversationID: strings.TrimSpace(req.ConversationID),
|
||
AssistantID: strings.TrimSpace(req.AssistantID),
|
||
RunID: strings.TrimSpace(req.RunID),
|
||
MemoryType: memoryType,
|
||
Title: title,
|
||
Content: content,
|
||
NormalizedContent: normalizedContent,
|
||
ContentHash: memoryutils.HashContent(memoryType, normalizedContent),
|
||
Confidence: normalizeManageScore(req.Confidence, defaultManualConfidence),
|
||
Importance: normalizeManageScore(req.Importance, defaultManualImportance),
|
||
SensitivityLevel: normalizeManageSensitivity(req.SensitivityLevel, 0),
|
||
IsExplicit: normalizeManageBool(req.IsExplicit, true),
|
||
Status: model.MemoryItemStatusActive,
|
||
TTLAt: req.TTLAt,
|
||
VectorStatus: "pending",
|
||
}, nil
|
||
}
|
||
|
||
func buildUpdateItemFields(
|
||
req model.MemoryUpdateItemRequest,
|
||
current model.MemoryItem,
|
||
) (memorymodel.UpdateItemFields, model.MemoryItem, error) {
|
||
memoryType := current.MemoryType
|
||
if req.MemoryType != nil {
|
||
normalizedType, err := normalizeManagedMemoryType(*req.MemoryType)
|
||
if err != nil {
|
||
return memorymodel.UpdateItemFields{}, model.MemoryItem{}, err
|
||
}
|
||
memoryType = normalizedType
|
||
}
|
||
|
||
content := current.Content
|
||
if req.Content != nil {
|
||
normalizedContentValue, _, err := normalizeManagedContent(*req.Content)
|
||
if err != nil {
|
||
return memorymodel.UpdateItemFields{}, model.MemoryItem{}, err
|
||
}
|
||
content = normalizedContentValue
|
||
}
|
||
normalizedContent := normalizeContentForHash(content)
|
||
if normalizedContent == "" {
|
||
return memorymodel.UpdateItemFields{}, model.MemoryItem{}, respond.MemoryInvalidContent
|
||
}
|
||
|
||
title := current.Title
|
||
if req.Title != nil {
|
||
title = normalizeManagedTitle(*req.Title, content)
|
||
}
|
||
ttlAt := current.TTLAt
|
||
if req.ClearTTL {
|
||
ttlAt = nil
|
||
} else if req.TTLAt != nil {
|
||
ttlAt = req.TTLAt
|
||
}
|
||
|
||
fields := memorymodel.UpdateItemFields{
|
||
MemoryType: memoryType,
|
||
Title: title,
|
||
Content: content,
|
||
NormalizedContent: normalizedContent,
|
||
ContentHash: memoryutils.HashContent(memoryType, normalizedContent),
|
||
Confidence: normalizeManageScore(req.Confidence, current.Confidence),
|
||
Importance: normalizeManageScore(req.Importance, current.Importance),
|
||
SensitivityLevel: normalizeManageSensitivity(req.SensitivityLevel, current.SensitivityLevel),
|
||
IsExplicit: normalizeManageBool(req.IsExplicit, current.IsExplicit),
|
||
TTLAt: ttlAt,
|
||
}
|
||
|
||
after := current
|
||
after.MemoryType = fields.MemoryType
|
||
after.Title = fields.Title
|
||
after.Content = fields.Content
|
||
after.NormalizedContent = strPtr(fields.NormalizedContent)
|
||
after.ContentHash = strPtr(fields.ContentHash)
|
||
after.Confidence = fields.Confidence
|
||
after.Importance = fields.Importance
|
||
after.SensitivityLevel = fields.SensitivityLevel
|
||
after.IsExplicit = fields.IsExplicit
|
||
after.TTLAt = fields.TTLAt
|
||
return fields, after, nil
|
||
}
|
||
|
||
func normalizeManagedMemoryType(raw string) (string, error) {
|
||
normalized := memorymodel.NormalizeMemoryType(raw)
|
||
if normalized == "" {
|
||
return "", respond.MemoryInvalidType
|
||
}
|
||
return normalized, nil
|
||
}
|
||
|
||
func normalizeManagedContent(raw string) (string, string, error) {
|
||
content := strings.TrimSpace(raw)
|
||
if content == "" {
|
||
return "", "", respond.MemoryInvalidContent
|
||
}
|
||
normalized := normalizeContentForHash(content)
|
||
if normalized == "" {
|
||
return "", "", respond.MemoryInvalidContent
|
||
}
|
||
return content, normalized, nil
|
||
}
|
||
|
||
func normalizeManagedTitle(raw string, content string) string {
|
||
title := strings.TrimSpace(raw)
|
||
if title != "" {
|
||
return title
|
||
}
|
||
content = strings.TrimSpace(content)
|
||
if content == "" {
|
||
return "未命名记忆"
|
||
}
|
||
runes := []rune(content)
|
||
if len(runes) > 24 {
|
||
return string(runes[:24])
|
||
}
|
||
return content
|
||
}
|
||
|
||
func normalizeManageScore(value *float64, defaultValue float64) float64 {
|
||
if value == nil {
|
||
return clamp01(defaultValue)
|
||
}
|
||
return clamp01(*value)
|
||
}
|
||
|
||
func normalizeManageSensitivity(value *int, defaultValue int) int {
|
||
if value == nil {
|
||
return defaultValue
|
||
}
|
||
if *value < 0 {
|
||
return defaultValue
|
||
}
|
||
return *value
|
||
}
|
||
|
||
func normalizeManageBool(value *bool, defaultValue bool) bool {
|
||
if value == nil {
|
||
return defaultValue
|
||
}
|
||
return *value
|
||
}
|
||
|
||
func resolveUpdateMemoryType(req model.MemoryUpdateItemRequest) string {
|
||
if req.MemoryType == nil {
|
||
return ""
|
||
}
|
||
return strings.TrimSpace(*req.MemoryType)
|
||
}
|
||
|
||
func strPtr(value string) *string {
|
||
value = strings.TrimSpace(value)
|
||
if value == "" {
|
||
return nil
|
||
}
|
||
result := value
|
||
return &result
|
||
}
|
||
|
||
func (s *ManageService) recordManageAction(
|
||
ctx context.Context,
|
||
operation string,
|
||
userID int,
|
||
memoryID int64,
|
||
memoryType string,
|
||
success bool,
|
||
err error,
|
||
) {
|
||
if s == nil {
|
||
return
|
||
}
|
||
|
||
status := "success"
|
||
level := memoryobserve.LevelInfo
|
||
if !success || err != nil {
|
||
status = "error"
|
||
level = memoryobserve.LevelWarn
|
||
}
|
||
|
||
s.metrics.AddCounter(memoryobserve.MetricManageTotal, 1, map[string]string{
|
||
"operation": strings.TrimSpace(operation),
|
||
"status": status,
|
||
})
|
||
s.observer.Observe(ctx, memoryobserve.Event{
|
||
Level: level,
|
||
Component: memoryobserve.ComponentManage,
|
||
Operation: memoryobserve.OperationManage,
|
||
Fields: map[string]any{
|
||
"user_id": userID,
|
||
"memory_id": memoryID,
|
||
"action": strings.TrimSpace(operation),
|
||
"memory_type": strings.TrimSpace(memoryType),
|
||
"success": success && err == nil,
|
||
"error": err,
|
||
"error_code": memoryobserve.ClassifyError(err),
|
||
},
|
||
})
|
||
}
|