Files

212 lines
6.7 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.
package storage
import (
"database/sql"
"encoding/json"
"fmt"
"log"
"os"
"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"`
SourceMemories []string `json:"source_memories,omitempty"`
Version int `json:"version"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
}
// 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,
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)
}
return &StandingStore{db: db, path: path}, nil
}
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。
func (s *StandingStore) Upsert(qid, question, answer string, source []string) (*StandingAnswer, error) {
s.mu.Lock()
defer s.mu.Unlock()
now := time.Now()
sm, _ := json.Marshal(source)
if sm == nil {
sm = []byte("[]")
}
// 查已有
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=?, source_memories=?, version=?, updated_at=? WHERE question_id=?`,
answer, 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,source_memories,version,created_at,updated_at)
VALUES(?,?,?,?,?,?,?)`,
qid, question, answer, string(sm), newVer, created, now.Format(time.RFC3339),
)
}
if err != nil {
return nil, fmt.Errorf("upsert: %w", err)
}
return &StandingAnswer{
QuestionID: qid, Question: question, Answer: answer,
SourceMemories: source, Version: newVer, CreatedAt: now, UpdatedAt: now,
}, nil
}
// Get 直读一条(主键查询,零检索零 LLM)。无则 (nil, nil)。
func (s *StandingStore) Get(qid string) (*StandingAnswer, error) {
s.mu.RLock()
defer s.mu.RUnlock()
var a StandingAnswer
var sm string
var created, updated string
err := s.db.QueryRow(
`SELECT question_id,question,answer,source_memories,version,created_at,updated_at
FROM standing_answers WHERE question_id=?`, qid,
).Scan(&a.QuestionID, &a.Question, &a.Answer, &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.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,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
if err := rows.Scan(&a.QuestionID, &a.Question, &a.Answer, &sm, &a.Version, &created, &updated); err != nil {
return nil, err
}
a.SourceMemories = parseSourceEvents(sm)
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
}