Files
小唯 7f7171ac14 feat(recall): 召回契约字段 + trace 回溯 + 生命周期/实体质量判据(工作树收口)
这批是 10-26~27 已在生产二进制(zhiyid-protectrails-20261027)里运行、
但一直留在工作树未提交的改动。收口原因:三件改造要开分支,工作树脏 =
分支基准与回滚点都不存在。

主要内容:
- api/routes/contract.go + trace.go:召回响应契约字段(trace_id/status/scope/
  continuation/channel)与 /api/v1/trace 回溯端点
- governance/entity_quality.go:实体质量闸
- storage/trace.go + recall.go/recall_write_buffer.go:召回写入缓冲与轨迹
- 测试:contract/recall_contract_fields/recall_lifecycle/stale_lifecycle/
  entity_quality/trace

同时修一个 flaky:recall_lifecycle_test 原本硬编码「今天 11:00 已过」,
凌晨跑就会把「已失效」fixture 当成仍有效。改成相对时间(过期=now-1h),
生命周期判据与运行时刻无关。修完 go test ./internal/api/routes ./internal/storage 全绿。
2026-10-28 02:09:19 +08:00

315 lines
8.8 KiB
Go
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// 织忆 MemoryWeave — L2 pattern 存储(t_d32e5f8a)
//
// 存储沿用现有 graph_nodes(type='pattern'),**不另开新表**(避免与现存图谱查询割裂;
// 表内另有 85 行 type='pattern_stat' 属旧 daemon 统计快照,与 L2 pattern 无关)。
// modernc sqlite 短命单发开/关,不持长连接、不碰 state.db。
//
// 写入幂等语义(复活 L1→L2 occurrence_count 驱动):
// - 同名 pattern 节点存在 → occurrence_count += 1、last_seen 刷新、props 合并(新键覆盖、旧键保留)
// - 不存在 → INSERT(occurrence_count=1、first_seen=last_seen=now)
// 命名键:id = name = "tool_combo:<tools>" / "workflow:cluster-N-<fingerprint>",
// namespace = "daemon-distill"(沿用旧 Python daemon 约定)。
package pattern
import (
"database/sql"
"encoding/json"
"log"
"os"
"path/filepath"
"sort"
"sync"
"time"
_ "modernc.org/sqlite"
)
// GraphPatternStore pattern 在 graph_nodes(type='pattern') 上的读写。
// modernc 纯 Go,无 CGO,测试可用 t.TempDir() 的 db 路径。
type GraphPatternStore struct {
dbPath string
mu sync.Mutex
once sync.Once
db *sql.DB
closed bool
}
// NewGraphPatternStore 指向 graph.db(生产 /var/lib/memoryweave/graph.db)。
// 测试传 t.TempDir() 路径。
func NewGraphPatternStore(dbPath string) *GraphPatternStore {
if dbPath == "" {
dbPath = "/var/lib/memoryweave/graph.db"
}
return &GraphPatternStore{dbPath: dbPath}
}
// SetGraphPathForTest 测试专用:改库路径 + 重置单例(下次调用按新路径重开)。
func (s *GraphPatternStore) SetForTest(p string) {
s.mu.Lock()
defer s.mu.Unlock()
s.dbPath = p
s.once = sync.Once{}
if s.db != nil {
s.db.Close()
s.db = nil
}
s.closed = false
}
// open 懒开库(WAL 兼容:先清 stale WAL 只在能 stat 到时才动,避免误删新建库)。
func (s *GraphPatternStore) open() (*sql.DB, error) {
s.once.Do(func() {
// 目录不存在时先建(cron 单发到新环境/临时库路径不炸)
if dir := filepath.Dir(s.dbPath); dir != "" && dir != "." {
if err := os.MkdirAll(dir, 0o755); err != nil {
log.Printf("[pattern] mkdir %s: %v", dir, err)
return
}
}
db, err := sql.Open("sqlite", "file:"+s.dbPath+
"?_pragma=journal_mode(WAL)&_pragma=busy_timeout(5000)&_pragma=synchronous(NORMAL)")
if err != nil {
log.Printf("[pattern] open graph.db %s: %v", s.dbPath, err)
return
}
// 建表兜底(graph_nodes 生产已有;测试临时库需要)
_, _ = db.Exec(`CREATE TABLE IF NOT EXISTS graph_nodes (
id TEXT PRIMARY KEY,
name TEXT NOT NULL,
type TEXT NOT NULL,
namespace TEXT NOT NULL DEFAULT '',
properties TEXT DEFAULT '{}',
created_at TEXT NOT NULL,
last_updated_at TEXT NOT NULL DEFAULT '')`)
s.db = db
})
if s.db == nil {
return nil, os.ErrNotExist
}
return s.db, nil
}
// Close 单发退出时关库。
func (s *GraphPatternStore) Close() {
s.mu.Lock()
defer s.mu.Unlock()
if s.db != nil {
s.db.Close()
s.db = nil
}
s.closed = true
}
// propsJSON 一个 pattern 节点的 properties(graph_nodes.properties 列)。
type propsJSON map[string]interface{}
// UpsertPatterns 把检测出的 pattern 写回 graph_nodes(type='pattern')。
// 返回新建数与更新数。空输入 → 0,0(AC1:空库不报错)。
func (s *GraphPatternStore) UpsertPatterns(patterns []Pattern) (created, updated int, err error) {
if len(patterns) == 0 {
return 0, 0, nil
}
db, oerr := s.open()
if oerr != nil {
return 0, 0, oerr
}
now := time.Now().UTC().Format(time.RFC3339)
for _, p := range patterns {
// 读现有
var (
id string
propsRaw string
hasExisting bool
)
row := db.QueryRow(`SELECT id, properties FROM graph_nodes WHERE name=? AND type='pattern'`, p.Name)
if err := row.Scan(&id, &propsRaw); err == nil {
hasExisting = true
}
var props propsJSON
if hasExisting && propsRaw != "" && propsRaw != "null" {
_ = json.Unmarshal([]byte(propsRaw), &props)
}
if props == nil {
props = propsJSON{}
}
// 合并:新键覆盖、旧键保留
props["pattern_type"] = p.Type
props["data"] = p.Data
props["confidence"] = p.Confidence
tools := p.Tools
if tools == nil {
tools = []string{}
}
props["tools"] = tools
props["source_tasks"] = p.SourceTasks
var oldOcc int
if v, ok := props["occurrence_count"].(float64); ok {
oldOcc = int(v)
}
if hasExisting {
props["occurrence_count"] = oldOcc + 1
props["last_seen"] = now
b, _ := json.Marshal(props)
if _, werr := db.Exec(`UPDATE graph_nodes SET properties=?, last_updated_at=? WHERE id=?`,
string(b), now, id); werr != nil {
err = werr
continue
}
updated++
} else {
props["occurrence_count"] = 1
props["first_seen"] = now
props["last_seen"] = now
b, _ := json.Marshal(props)
if _, ierr := db.Exec(`INSERT INTO graph_nodes (id, name, type, namespace, properties, created_at, last_updated_at)
VALUES (?,?,?,?,?,?,?)`,
p.ID, p.Name, "pattern", "daemon-distill", string(b), now, now); ierr != nil {
err = ierr
continue
}
created++
}
}
if err != nil {
return
}
return
}
// GetPattern 按 id 取单个 pattern(graph_nodes WHERE id=? AND type='pattern')。
// 未找到 → sql.ErrNoRows。
func (s *GraphPatternStore) GetPattern(id string) (Pattern, error) {
db, oerr := s.open()
if oerr != nil {
return Pattern{}, oerr
}
var (
name, propsRaw string
)
if err := db.QueryRow(`SELECT id, name, properties FROM graph_nodes WHERE id=? AND type='pattern'`, id).
Scan(&id, &name, &propsRaw); err != nil {
return Pattern{}, err
}
p := Pattern{ID: id, Name: name}
var props propsJSON
if propsRaw != "" && propsRaw != "null" {
_ = json.Unmarshal([]byte(propsRaw), &props)
}
if props != nil {
if t, ok := props["pattern_type"].(string); ok {
p.Type = t
}
if d, ok := props["data"].(string); ok {
p.Data = d
}
if c, ok := props["confidence"].(float64); ok {
p.Confidence = c
}
if ts, ok := props["source_tasks"].([]interface{}); ok {
for _, v := range ts {
if s2, ok := v.(string); ok {
p.SourceTasks = append(p.SourceTasks, s2)
}
}
}
if tl, ok := props["tools"].([]interface{}); ok {
for _, v := range tl {
if s2, ok := v.(string); ok {
p.Tools = append(p.Tools, s2)
}
}
}
}
return p, nil
}
// ListPatterns 列出 graph_nodes(type='pattern'),按 occurrence_count 降序取 top N。
// 0 / 空库 → 空列表不报错(AC1)。
// 单行 NULL/空 id 不致全盘失败:跳过并计数(见 AC1 差错容忍)。
// 名空间 quarantine 排除(AC2:stat-template/单句主题不视为真 pattern)。
func (s *GraphPatternStore) ListPatterns(limit int) ([]Pattern, int, error) {
if limit <= 0 {
limit = 10
}
db, oerr := s.open()
if oerr != nil {
return nil, 0, oerr
}
// 使用 COALESCE 防止 NULL 导致 Scan 错误;同时排除 quarantine 名空间(AC2)
rows, qerr := db.Query(`SELECT COALESCE(id,''), COALESCE(name,''), COALESCE(properties,'') FROM graph_nodes WHERE type='pattern' AND COALESCE(namespace,'') != 'quarantine' LIMIT ?`, limit*3)
if qerr != nil {
return nil, 0, qerr
}
defer rows.Close()
type raw struct {
ID, Name, Props string
}
var all []raw
var skipped int
for rows.Next() {
var r raw
if serr := rows.Scan(&r.ID, &r.Name, &r.Props); serr != nil {
return nil, 0, serr
}
if r.ID == "" {
skipped++
continue
}
all = append(all, r)
}
// 解析 props + occurrence 排序(sqlite 无 json 聚合,取 limit*3 再内存排)
out := make([]Pattern, 0, len(all))
for _, r := range all {
p := Pattern{ID: r.ID, Name: r.Name}
var props propsJSON
if r.Props != "" && r.Props != "null" {
_ = json.Unmarshal([]byte(r.Props), &props)
}
if props != nil {
if t, ok := props["pattern_type"].(string); ok {
p.Type = t
}
if d, ok := props["data"].(string); ok {
p.Data = d
}
if c, ok := props["confidence"].(float64); ok {
p.Confidence = c
}
if ts, ok := props["source_tasks"].([]interface{}); ok {
for _, v := range ts {
if s2, ok := v.(string); ok {
p.SourceTasks = append(p.SourceTasks, s2)
}
}
}
if tl, ok := props["tools"].([]interface{}); ok {
for _, v := range tl {
if s2, ok := v.(string); ok {
p.Tools = append(p.Tools, s2)
}
}
}
// occurrence_count 已在 props 中,但 ListPatterns 不再使用它做排序
// 保留该字段以免反序列化时丢失(若后续代码仍需)
if o, ok := props["occurrence_count"].(float64); ok {
// 暂不使用,仅保留
_ = o
}
}
out = append(out, p)
}
// occurrence 降序(去重后 source_tasks 长度近似;存量行 source_tasks 可能为空 → 靠 0 兜底)
sort.SliceStable(out, func(i, j int) bool {
return len(out[i].SourceTasks) > len(out[j].SourceTasks)
})
if len(out) > limit {
out = out[:limit]
}
return out, skipped, nil
}