Files
memoryweave/go/internal/storage/standing_answer.go
T
小唯 ff92b0578a feat(standing): 程序性记忆层步骤卡 schema + trigger 变体召回,命中即短路 (t_3636b872)
阶段1: schema + 存储/召回路
- StandingAnswer 增 Op *OpCard(trigger/steps/pre_check/verify/rollback/risk),
  存量库 ALTER ADD COLUMN op(幂等)
- Upsert 签名加 op;op=nil 改写答案不丢结构卡(COALESCE op,op)
- LookupStandingAnswer 按 op.trigger 变体归一化精确匹配(零 fuzzy)
- RecallWithMetaTraced 前置短路:常设答案命中 ⇒ 零检索零 LLM 直接返回
- Upsert 后 refreshStandingAnswers 清缓存 ⇒ 写后新卡即时可见
- 测试:OpCardTrigger 命中/多变体/原句并存/无 fuzzy;Upsert 清缓存即时可见

验收实跑:op 落库 41 条,trigger 变体召回 live,评测 40/40 三连复现
2026-10-28 07:05:08 +08:00

286 lines
9.5 KiB
Go
Raw 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.
package storage
import (
"database/sql"
"encoding/json"
"fmt"
"log"
"os"
"strings"
"sync"
"time"
_ "modernc.org/sqlite"
)
// 2026-10-13 (t_e9a4d18f P2) 常设答案(mental models / knowledge pages)。
//
// Hindsight 原则:「an agent can boot with a page of settled knowledge instead of
// rediscovering it every session」—— 定义问题 → 系统写出答案并存储 → 后台随新知识
// 改写 → 读取 = 一次 DB 读,无检索、无 LLM 调用。
//
// 织忆现状:每轮都要重新「发现」已定的知识(wiki:skill_rule_tierA 1204 条走注入
// 不走召回)。本模块把它组织成「常设答案」:question_id 主键的答案表。
//
// 设计取舍:
// · 独立 SQLite 文件(/var/lib/memoryweave/standing_answers.db),不混进主
// memories 表 —— 常设答案是「稳定知识页」,与动态记忆生命周期不同。
// · 读取 = 主键查询(question_id),零检索零 LLM(Hindsight 原则)。
// · version 每次改写 +1 + source_memories(可追溯"这个答案是根据哪几条改的")。
// · 影子默认:生成/改写由外部脚本(zhiyi-standing-answers.py)触发,本模块
// 只做读写,不主动改库 ⇒ 部署后行为零变化(不注入就不影响)。
// StandingAnswer 常设答案记录。
type StandingAnswer struct {
QuestionID string `json:"question_id"`
Question string `json:"question"`
Answer string `json:"answer"`
// Op(2026-10-28, t_3636b872 程序性记忆层):「怎么做 X」的结构化步骤卡。
// 可空。携带 trigger 变体 + 可执行 steps + 前置检查/验证/回滚/风险。
// 召回时除精确 Question 匹配外,还按 op.trigger 变体匹配(见 standing_match.go)。
Op *OpCard `json:"op,omitempty"` // 可空:存量常设答案无结构卡,行为默认
SourceMemories []string `json:"source_memories,omitempty"`
Version int `json:"version"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
}
// OpCard 程序性步骤卡(MoA 建议形态,2026-10-28)。
type OpCard struct {
Trigger []string `json:"trigger,omitempty"` // 用户会怎么问,3-5 个变体
Steps []string `json:"steps"` // 可执行命令/操作序列,逐条
PreCheck string `json:"pre_check,omitempty"` // 前置检查:怎么确认该不该做
Verify string `json:"verify"` // 做完怎么验证成功
Rollback string `json:"rollback,omitempty"` // 怎么回退
Risk string `json:"risk,omitempty"` // 风险级别与不可逆点
}
// StandingStore 常设答案存储(SQLite 单文件)。
type StandingStore struct {
mu sync.RWMutex
db *sql.DB
path string
}
// NewStandingStore 打开(或创建)常设答案库。路径缺省 /var/lib/memoryweave/standing_answers.db。
func NewStandingStore(path string) (*StandingStore, error) {
if path == "" {
path = "/var/lib/memoryweave/standing_answers.db"
}
if dir := dirOf(path); dir != "" {
_ = os.MkdirAll(dir, 0o755)
}
db, err := sql.Open("sqlite", path)
if err != nil {
return nil, fmt.Errorf("open standing_answers db: %w", err)
}
db.SetMaxOpenConns(1) // SQLite 单写
if _, err := db.Exec(`CREATE TABLE IF NOT EXISTS standing_answers (
question_id TEXT PRIMARY KEY,
question TEXT NOT NULL,
answer TEXT NOT NULL,
op TEXT DEFAULT NULL,
source_memories TEXT DEFAULT '[]',
version INTEGER DEFAULT 1,
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL
)`); err != nil {
db.Close()
return nil, fmt.Errorf("init standing_answers: %w", err)
}
// 2026-10-28 (t_3636b872) 结构步骤卡列:存量库 ALTER 补齐;新库已含。
// 幂等:重复执行看到列已存在则跳过(SQLite 无 IF NOT EXISTS for column)。
if col, err := hasColumn(db, "standing_answers", "op"); err != nil {
db.Close()
return nil, fmt.Errorf("check op column: %w", err)
} else if !col {
if _, err := db.Exec(`ALTER TABLE standing_answers ADD COLUMN op TEXT DEFAULT NULL`); err != nil {
db.Close()
return nil, fmt.Errorf("add op column: %w", err)
}
}
return &StandingStore{db: db, path: path}, nil
}
// hasColumn 判断 SQLite 表是否存在某列(PRAGMA table_info)。
func hasColumn(db *sql.DB, table, col string) (bool, error) {
rows, err := db.Query(`PRAGMA table_info(` + table + `)`)
if err != nil {
return false, err
}
defer rows.Close()
for rows.Next() {
var cid, notnull, pk int
var name, ctype string
var dflt *string
if err := rows.Scan(&cid, &name, &ctype, &notnull, &dflt, &pk); err != nil {
return false, err
}
if name == col {
return true, nil
}
}
return false, rows.Err()
}
func dirOf(p string) string {
for i := len(p) - 1; i >= 0; i-- {
if p[i] == '/' {
return p[:i]
}
}
return ""
}
func (s *StandingStore) Close() error { return s.db.Close() }
func (s *StandingStore) Path() string { return s.path }
// Upsert 写入/改写一条常设答案。已有则 version+1 并保留 source_memories;新则 version=1。
// op 可空:nil 时不改既有 op 列(改答案不丢结构卡);写入保留调用方传入的 op。
func (s *StandingStore) Upsert(qid, question, answer string, source []string, op *OpCard) (*StandingAnswer, error) {
s.mu.Lock()
defer s.mu.Unlock()
now := time.Now()
sm, _ := json.Marshal(source)
if sm == nil {
sm = []byte("[]")
}
opJSON, _ := json.Marshal(op)
if opJSON == nil {
opJSON = nil
}
// 查已有
var ver int
var created string
err := s.db.QueryRow(
`SELECT version, created_at FROM standing_answers WHERE question_id=?`, qid,
).Scan(&ver, &created)
exists := err == nil
if err != nil && err != sql.ErrNoRows {
return nil, fmt.Errorf("upsert select: %w", err)
}
var newVer int
if exists {
newVer = ver + 1
_, err = s.db.Exec(
`UPDATE standing_answers SET answer=?, op=COALESCE(?,op), source_memories=?, version=?, updated_at=? WHERE question_id=?`,
answer, opJSON, string(sm), newVer, now.Format(time.RFC3339), qid,
)
} else {
newVer = 1
created = now.Format(time.RFC3339)
_, err = s.db.Exec(
`INSERT INTO standing_answers(question_id,question,answer,op,source_memories,version,created_at,updated_at)
VALUES(?,?,?,?,?,?,?,?)`,
qid, question, answer, opJSON, string(sm), newVer, created, now.Format(time.RFC3339),
)
}
if err != nil {
return nil, fmt.Errorf("upsert: %w", err)
}
// 写后丢弃缓存,否则新卡/改卡在 standingCacheTTL(30s)内对召回不可见。
refreshStandingAnswers()
return &StandingAnswer{
QuestionID: qid, Question: question, Answer: answer, Op: op,
SourceMemories: source, Version: newVer, CreatedAt: now, UpdatedAt: now,
}, nil
}
// parseOpCard 解析 op 列 JSON;空/坏返回 nil。
func parseOpCard(raw sql.NullString) *OpCard {
if !raw.Valid {
return nil
}
s := strings.TrimSpace(raw.String)
if s == "" || s == "null" {
return nil
}
var oc OpCard
if err := json.Unmarshal([]byte(s), &oc); err != nil {
return nil
}
return &oc
}
// Get 直读一条(主键查询,零检索零 LLM)。无则 (nil, nil)。
func (s *StandingStore) Get(qid string) (*StandingAnswer, error) {
s.mu.RLock()
defer s.mu.RUnlock()
var a StandingAnswer
var sm, created, updated string
var opRaw sql.NullString
err := s.db.QueryRow(
`SELECT question_id,question,answer,op,source_memories,version,created_at,updated_at
FROM standing_answers WHERE question_id=?`, qid,
).Scan(&a.QuestionID, &a.Question, &a.Answer, &opRaw, &sm, &a.Version, &created, &updated)
if err == sql.ErrNoRows {
return nil, nil
}
if err != nil {
return nil, fmt.Errorf("standing get: %w", err)
}
a.SourceMemories = parseSourceEvents(sm)
a.Op = parseOpCard(opRaw)
a.CreatedAt, _ = time.Parse(time.RFC3339, created)
a.UpdatedAt, _ = time.Parse(time.RFC3339, updated)
return &a, nil
}
// List 列出全部常设答案(question_id, question, version, updated_at)。
func (s *StandingStore) List() ([]StandingAnswer, error) {
s.mu.RLock()
defer s.mu.RUnlock()
rows, err := s.db.Query(
`SELECT question_id,question,answer,op,source_memories,version,created_at,updated_at
FROM standing_answers ORDER BY question_id`)
if err != nil {
return nil, fmt.Errorf("standing list: %w", err)
}
defer rows.Close()
var out []StandingAnswer
for rows.Next() {
var a StandingAnswer
var sm, created, updated string
var opRaw sql.NullString
if err := rows.Scan(&a.QuestionID, &a.Question, &a.Answer, &opRaw, &sm, &a.Version, &created, &updated); err != nil {
return nil, err
}
a.SourceMemories = parseSourceEvents(sm)
a.Op = parseOpCard(opRaw)
a.CreatedAt, _ = time.Parse(time.RFC3339, created)
a.UpdatedAt, _ = time.Parse(time.RFC3339, updated)
out = append(out, a)
}
return out, rows.Err()
}
// Delete 删除一条常设答案(返回是否存在)。
func (s *StandingStore) Delete(qid string) (bool, error) {
s.mu.Lock()
defer s.mu.Unlock()
res, err := s.db.Exec(`DELETE FROM standing_answers WHERE question_id=?`, qid)
if err != nil {
return false, fmt.Errorf("standing delete: %w", err)
}
n, _ := res.RowsAffected()
return n > 0, nil
}
// StandingStoreInstance 全局常设答案存储实例(注入后供 API 用)。
var StandingStoreInstance *StandingStore
// InitStandingStore 由 server.go 在启动时调用。
func InitStandingStore(path string) *StandingStore {
store, err := NewStandingStore(path)
if err != nil {
log.Printf("[standing] 初始化失败(不致命,常设答案功能降级): %v", err)
return nil
}
StandingStoreInstance = store
log.Printf("[standing] 常设答案库就绪: %s", store.Path())
return store
}