feat(zhiyi): ②L2 模式检测+召回注入 (t_d32e5f8a) — 复活 L1→L2 pattern 蒸馏: 新 internal/pattern 包(工具组合频率≥3 + 路径 cosine≥0.85 聚类,设计§4.1)→ upsert graph_nodes(type='pattern',ns=daemon-distill)(与 85 存量同表不开新表·modernc sqlite 短命开/关·不碰 state.db); API POST /patterns/detect + GET /patterns + zhiyi-cli pattern detect/list(cron 可单发); 召回注入 env 门控 ZHIYI_PATTERN_RECALL 默认关⇒零行为变化; 单测 12 用例(detect5+store4+注入3+route4 含空库幂等)PASS; 零新依赖不碰 state.db
This commit is contained in:
@@ -10,6 +10,7 @@ import (
|
||||
"net/http"
|
||||
"os"
|
||||
"sort"
|
||||
"strconv"
|
||||
"strings"
|
||||
"unicode/utf8"
|
||||
)
|
||||
@@ -92,6 +93,8 @@ func main() {
|
||||
runErr = runStats(apiKeyVal)
|
||||
case "entity":
|
||||
runErr = runEntity(args, apiKeyVal)
|
||||
case "pattern":
|
||||
runErr = runPattern(args, apiKeyVal)
|
||||
case "help", "--help", "-h":
|
||||
flag.Usage()
|
||||
os.Exit(0)
|
||||
@@ -130,6 +133,7 @@ func usage() {
|
||||
recall <query> 语义搜索,返回 top-10 结果
|
||||
stats 显示系统统计(记忆数、蒸馏状态等)
|
||||
entity <name> 查询实体详情(出现次数、关联记忆)
|
||||
pattern <detect|list> L2 模式检测/列出(detect=手动触发检测,list=列出已检测)
|
||||
|
||||
示例:
|
||||
zhiyi tree
|
||||
@@ -461,6 +465,85 @@ func runStats(apiKey string) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// runPattern L2 模式检测 CLI 子命令(t_d32e5f8a,cron 单发)。
|
||||
// 子命令:
|
||||
// zhiyi pattern detect [--limit N] 触发检测(扫 L1 蒸馏记忆 → 工具组合/路径聚类 → 写 graph_nodes)
|
||||
// zhiyi pattern list [N] 列出已检测的 pattern(默认 20)
|
||||
func runPattern(args []string, apiKey string) error {
|
||||
// 子命令(默认 detect)
|
||||
sub := "detect"
|
||||
rest := []string{}
|
||||
if len(args) > 0 {
|
||||
// 允许 "detect" / "list" 显式指定,或把第一个参数当 limit(list N)
|
||||
switch args[0] {
|
||||
case "detect", "list":
|
||||
sub = args[0]
|
||||
rest = args[1:]
|
||||
default:
|
||||
// 数字参数 = list 的 limit
|
||||
if n, err := strconv.Atoi(args[0]); err == nil && n > 0 {
|
||||
sub = "list"
|
||||
rest = []string{args[0]}
|
||||
} else {
|
||||
rest = args
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if sub == "list" {
|
||||
limit := "20"
|
||||
if len(rest) > 0 {
|
||||
limit = rest[0]
|
||||
}
|
||||
var resp struct {
|
||||
Patterns []struct {
|
||||
ID string `json:"id"`
|
||||
Type string `json:"type"`
|
||||
Name string `json:"name"`
|
||||
Confidence float64 `json:"confidence"`
|
||||
Tools []string `json:"tools"`
|
||||
} `json:"patterns"`
|
||||
Count int `json:"count"`
|
||||
}
|
||||
if err := apiGet("/api/v1/patterns?limit="+limit, &resp, apiKey); err != nil {
|
||||
return err
|
||||
}
|
||||
fmt.Printf("📐 已检测模式 [%s] (%d)\n", *ns, resp.Count)
|
||||
fmt.Println(strings.Repeat("─", 50))
|
||||
for i, p := range resp.Patterns {
|
||||
if i >= 30 {
|
||||
fmt.Printf(" … 还有 %d 个\n", len(resp.Patterns)-30)
|
||||
break
|
||||
}
|
||||
tools := ""
|
||||
if len(p.Tools) > 0 {
|
||||
tools = strings.Join(p.Tools, ",")
|
||||
}
|
||||
fmt.Printf(" [%s] %s conf=%.2f %s\n", p.Type, p.Name, p.Confidence, tools)
|
||||
}
|
||||
if resp.Count == 0 {
|
||||
fmt.Println(" (暂无已检测模式)")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// detect
|
||||
var resp struct {
|
||||
Scanned int `json:"scanned"`
|
||||
Created int `json:"created"`
|
||||
Updated int `json:"updated"`
|
||||
Detected int `json:"detected"`
|
||||
}
|
||||
if err := apiPost("/api/v1/patterns/detect", map[string]interface{}{
|
||||
"namespace": *ns,
|
||||
}, &resp, apiKey); err != nil {
|
||||
return err
|
||||
}
|
||||
fmt.Printf("🔬 L2 模式检测 [%s] 扫描 %d 条 → 命中 %d(新建 %d / 更新 %d)\n",
|
||||
*ns, resp.Scanned, resp.Detected, resp.Created, resp.Updated)
|
||||
return nil
|
||||
}
|
||||
|
||||
func runEntity(args []string, apiKey string) error {
|
||||
if len(args) == 0 {
|
||||
return fmt.Errorf("用法: zhiyi entity <name>")
|
||||
|
||||
@@ -0,0 +1,107 @@
|
||||
// 织忆 MemoryWeave — L2 模式 API(t_d32e5f8a)
|
||||
//
|
||||
// 设计 §4.1 端点:
|
||||
// POST /api/v1/patterns/detect 手动触发模式检测(扫 L1 蒸馏记忆 → 工具组合频率 + 路径聚类
|
||||
// → 写 graph_nodes type='pattern')。短命单发:modernc sqlite
|
||||
// 开/关不占长连接、不碰 state.db(规避当年 daemon main_loop
|
||||
// 退役根因)—— 可挂 cron 单发。
|
||||
// GET /api/v1/patterns 列出检测到的模式(按 source_tasks 长度降序)。
|
||||
package routes
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"os"
|
||||
"strconv"
|
||||
|
||||
"github.com/xiaoxue/memoryweave/internal/models"
|
||||
"github.com/xiaoxue/memoryweave/internal/pattern"
|
||||
"github.com/xiaoxue/memoryweave/internal/storage"
|
||||
)
|
||||
|
||||
// PatternAPI L2 模式端点。
|
||||
type PatternAPI struct {
|
||||
Store *pattern.GraphPatternStore
|
||||
Provider *pattern.PatternProvider
|
||||
LDB func() storage.LanceDB // 扫 L1 记忆(distilled)
|
||||
Cfg pattern.Config
|
||||
}
|
||||
|
||||
// NewPatternAPI 构造 L2 模式端点。
|
||||
func NewPatternAPI(store *pattern.GraphPatternStore, provider *pattern.PatternProvider, ldb func() storage.LanceDB) *PatternAPI {
|
||||
cfg := pattern.DefaultConfig()
|
||||
// cron 单发跑大批量时可放宽扫描上限
|
||||
if v := os.Getenv("ZHIYI_PATTERN_MAX_RECORDS"); v != "" {
|
||||
if n, err := strconv.Atoi(v); err == nil && n > 0 {
|
||||
cfg.MaxRecords = n
|
||||
}
|
||||
}
|
||||
return &PatternAPI{Store: store, Provider: provider, LDB: ldb, Cfg: cfg}
|
||||
}
|
||||
|
||||
// GET /api/v1/patterns — 列出所有检测到的模式(AC1:空库返回 count=0 不报错)。
|
||||
func (pa *PatternAPI) List(w http.ResponseWriter, r *http.Request) {
|
||||
limit := pa.Cfg.TopKPatternList
|
||||
if v := r.URL.Query().Get("limit"); v != "" {
|
||||
if n, err := strconv.Atoi(v); err == nil && n > 0 {
|
||||
limit = n
|
||||
}
|
||||
}
|
||||
pats, err := pa.Store.ListPatterns(limit)
|
||||
if err != nil {
|
||||
respondError(w, 500, "list patterns: "+err.Error())
|
||||
return
|
||||
}
|
||||
respond(w, 200, map[string]interface{}{
|
||||
"patterns": pats,
|
||||
"count": len(pats),
|
||||
})
|
||||
}
|
||||
|
||||
// POST /api/v1/patterns/detect — 手动触发模式检测。
|
||||
// body 可选 {"limit": N, "namespace": "hermes-main"}。
|
||||
// 流程:LanceDB Scan(limit, ns) → pattern.DetectFromRecords → UpsertPatterns(graph_nodes)。
|
||||
// 空库/无命中 → created/updated=0,不报错(AC1)。
|
||||
func (pa *PatternAPI) Detect(w http.ResponseWriter, r *http.Request) {
|
||||
var req struct {
|
||||
Limit int `json:"limit"`
|
||||
Namespace string `json:"namespace"`
|
||||
}
|
||||
if r.Body != nil {
|
||||
_ = json.NewDecoder(r.Body).Decode(&req) // 空 body 也合法(用默认)
|
||||
}
|
||||
if req.Limit <= 0 {
|
||||
req.Limit = pa.Cfg.MaxRecords
|
||||
}
|
||||
ldb := pa.LDB()
|
||||
if ldb == nil {
|
||||
respondError(w, 503, "lancedb unavailable")
|
||||
return
|
||||
}
|
||||
records, err := ldb.Scan(req.Limit, req.Namespace)
|
||||
if err != nil {
|
||||
respondError(w, 500, "scan memories: "+err.Error())
|
||||
return
|
||||
}
|
||||
// 只拿蒸馏产物(L1 蒸馏记忆)做检测——原始对话/episode 不是「已验证」的解决路径
|
||||
// (与召回管线 2.5 步同源判据:raw/episodes 类不参与模式沉淀)。
|
||||
distilled := make([]models.MemoryRecord, 0, len(records))
|
||||
for _, rec := range records {
|
||||
if rec.Category == "distilled" || rec.Category == "" {
|
||||
distilled = append(distilled, rec)
|
||||
}
|
||||
}
|
||||
pats := pattern.DetectFromRecords(distilled, pa.Cfg)
|
||||
created, updated, uerr := pa.Store.UpsertPatterns(pats)
|
||||
if uerr != nil {
|
||||
respondError(w, 500, "upsert patterns: "+uerr.Error())
|
||||
return
|
||||
}
|
||||
respond(w, 200, map[string]interface{}{
|
||||
"scanned": len(records),
|
||||
"created": created,
|
||||
"updated": updated,
|
||||
"detected": len(pats),
|
||||
"patterns": pats,
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,132 @@
|
||||
package routes
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"testing"
|
||||
|
||||
"github.com/xiaoxue/memoryweave/internal/models"
|
||||
"github.com/xiaoxue/memoryweave/internal/pattern"
|
||||
"github.com/xiaoxue/memoryweave/internal/storage"
|
||||
)
|
||||
|
||||
// 织忆 — L2 模式 API 路由测试(t_d32e5f8a)
|
||||
// AC1: 空库 detect/list → 不报错(count=0)
|
||||
// AC2: 3 条同工具组合记忆 → detect 后 list 能查到 tool_combo pattern
|
||||
|
||||
// newPatternTestAPI 构造一个用临时 graph.db + 假 LanceDB 后端的 PatternAPI(无网络、无 CGO)。
|
||||
// 假后端只实现 PatternAPI 实际调用的 Scan(其余方法嵌 nil 接口,测试路径不会触达)。
|
||||
func newPatternTestAPI(t *testing.T, mems []models.MemoryRecord) *PatternAPI {
|
||||
t.Helper()
|
||||
store := pattern.NewGraphPatternStore(t.TempDir() + "/graph.db")
|
||||
t.Cleanup(store.Close)
|
||||
mlc := &patternScanLance{rows: mems}
|
||||
pemb := pattern.NewEmbedderProvider(&fakePatternEmbedder{})
|
||||
return NewPatternAPI(store, pattern.NewPatternProvider(store, pemb), func() storage.LanceDB { return mlc })
|
||||
}
|
||||
|
||||
// patternScanLance 覆写 Scan(PatternAPI.Detect 唯一用到的 LanceDB 方法);
|
||||
// 其余方法嵌 nil 接口 —— 本测试路径不会调用,触达即 panic(暴露误用)。
|
||||
type patternScanLance struct {
|
||||
storage.LanceDB
|
||||
rows []models.MemoryRecord
|
||||
}
|
||||
|
||||
func (f *patternScanLance) Scan(limit int, namespaceFilter string) ([]models.MemoryRecord, error) {
|
||||
if limit > 0 && len(f.rows) > limit {
|
||||
return f.rows[:limit], nil
|
||||
}
|
||||
return f.rows, nil
|
||||
}
|
||||
|
||||
// fakePatternEmbedder 确定性假向量(pattern.Provider 匹配测试用;注入测试走 storage 侧不走这里)。
|
||||
type fakePatternEmbedder struct{}
|
||||
|
||||
func (fakePatternEmbedder) EncodeSingle(text string) ([]float32, error) {
|
||||
v := make([]float32, 8)
|
||||
for i := 0; i < 8; i++ {
|
||||
v[i] = 0.1
|
||||
}
|
||||
return v, nil
|
||||
}
|
||||
|
||||
// TestPatterns_ListEmpty —— AC1:空库 list → 200 + count=0(不报错)。
|
||||
func TestPatterns_ListEmpty(t *testing.T) {
|
||||
api := newPatternTestAPI(t, nil)
|
||||
rec := httptest.NewRecorder()
|
||||
api.List(rec, httptest.NewRequest("GET", "/api/v1/patterns", nil))
|
||||
if rec.Code != http.StatusOK {
|
||||
t.Fatalf("空库 list 期望 200,实际 %d body=%s", rec.Code, rec.Body.String())
|
||||
}
|
||||
var resp map[string]interface{}
|
||||
_ = json.Unmarshal(rec.Body.Bytes(), &resp)
|
||||
if int(resp["count"].(float64)) != 0 {
|
||||
t.Fatalf("空库 count 期望 0,实际 %v", resp["count"])
|
||||
}
|
||||
}
|
||||
|
||||
// TestPatterns_DetectEmpty —— AC1:空库 detect → 200 + scanned=0/created=0(不报错)。
|
||||
func TestPatterns_DetectEmpty(t *testing.T) {
|
||||
api := newPatternTestAPI(t, nil)
|
||||
rec := httptest.NewRecorder()
|
||||
api.Detect(rec, httptest.NewRequest("POST", "/api/v1/patterns/detect", nil))
|
||||
if rec.Code != http.StatusOK {
|
||||
t.Fatalf("空库 detect 期望 200,实际 %d body=%s", rec.Code, rec.Body.String())
|
||||
}
|
||||
var resp map[string]interface{}
|
||||
_ = json.Unmarshal(rec.Body.Bytes(), &resp)
|
||||
if int(resp["scanned"].(float64)) != 0 || int(resp["created"].(float64)) != 0 {
|
||||
t.Fatalf("空库 detect 期望 0/0,实际 %v/%v", resp["scanned"], resp["created"])
|
||||
}
|
||||
}
|
||||
|
||||
// TestPatterns_DetectToolCombo —— AC2:3 条同工具组合蒸馏记忆 → detect 产出 1 个 tool_combo,
|
||||
// 且 list 能查到(sqlite graph_nodes 判据)。
|
||||
func TestPatterns_DetectToolCombo(t *testing.T) {
|
||||
mems := make([]models.MemoryRecord, 0, 3)
|
||||
for i, id := range []string{"pc_a", "pc_b", "pc_c"} {
|
||||
mems = append(mems, models.MemoryRecord{
|
||||
ID: id,
|
||||
Content: "用 jq git curl 处理第" + string(rune('一'+i)) + "项",
|
||||
Category: "distilled",
|
||||
})
|
||||
}
|
||||
api := newPatternTestAPI(t, mems)
|
||||
|
||||
rec := httptest.NewRecorder()
|
||||
api.Detect(rec, httptest.NewRequest("POST", "/api/v1/patterns/detect", nil))
|
||||
if rec.Code != http.StatusOK {
|
||||
t.Fatalf("detect 期望 200,实际 %d body=%s", rec.Code, rec.Body.String())
|
||||
}
|
||||
var dresp map[string]interface{}
|
||||
_ = json.Unmarshal(rec.Body.Bytes(), &dresp)
|
||||
if int(dresp["detected"].(float64)) < 1 {
|
||||
t.Fatalf("3 条同组合应检出 ≥1 个 pattern,实际 detected=%v", dresp["detected"])
|
||||
}
|
||||
// 用 list 再核一遍 sqlite 判据:确有 tool_combo 行
|
||||
lrec := httptest.NewRecorder()
|
||||
api.List(lrec, httptest.NewRequest("GET", "/api/v1/patterns", nil))
|
||||
var lresp struct {
|
||||
Count int `json:"count"`
|
||||
Patterns []struct {
|
||||
Type string `json:"type"`
|
||||
Name string `json:"name"`
|
||||
} `json:"patterns"`
|
||||
}
|
||||
if err := json.Unmarshal(lrec.Body.Bytes(), &lresp); err != nil {
|
||||
t.Fatalf("list 解析: %v (body=%s)", err, lrec.Body.String())
|
||||
}
|
||||
if lresp.Count < 1 {
|
||||
t.Fatalf("AC2 判据:detect 后 list count 应 ≥1,实际 %d (detected=%v)", lresp.Count, dresp["detected"])
|
||||
}
|
||||
var foundToolCombo bool
|
||||
for _, p := range lresp.Patterns {
|
||||
if p.Type == "tool_combo" {
|
||||
foundToolCombo = true
|
||||
}
|
||||
}
|
||||
if !foundToolCombo {
|
||||
t.Fatalf("AC2 判据:list 应含 tool_combo pattern,实际 %d 条均非 tool_combo", lresp.Count)
|
||||
}
|
||||
}
|
||||
@@ -23,6 +23,7 @@ import (
|
||||
"github.com/xiaoxue/memoryweave/internal/governance"
|
||||
"github.com/xiaoxue/memoryweave/internal/metrics"
|
||||
"github.com/xiaoxue/memoryweave/internal/models"
|
||||
"github.com/xiaoxue/memoryweave/internal/pattern"
|
||||
"github.com/xiaoxue/memoryweave/internal/redact"
|
||||
"github.com/xiaoxue/memoryweave/internal/selfoptimize"
|
||||
"github.com/xiaoxue/memoryweave/internal/storage"
|
||||
@@ -147,6 +148,26 @@ func NewServer() http.Handler {
|
||||
consolPipe := routes.NewConsolidationPipeline(ldb, graphStore, conflictDetector)
|
||||
consolPipe.SetDataDir("/var/lib/memoryweave/lancedb", "/var/lib/memoryweave/graph.db")
|
||||
|
||||
// ─── t_d32e5f8a L2 模式检测(MemOS 血统)─────────────────────────
|
||||
// 复活 L1→L2 pattern 蒸馏(原 Python daemon main_loop 退役后停摆):
|
||||
// pattern 节点存 graph_nodes(type='pattern'),与现有 85 存量同表,不另开新表。
|
||||
// modernc sqlite 短命单发开/关(UpsertPatterns/ListPatterns 开一次用一次即关),
|
||||
// 不持长连接、不碰 state.db —— 规避当年退役根因。
|
||||
// 召回注入 env 门控 ZHIYI_PATTERN_RECALL,默认 0 ⇒ 不注册 Provider,行为零变化。
|
||||
graphPath := os.Getenv("GRAPH_PATH")
|
||||
if graphPath == "" {
|
||||
graphPath = "/var/lib/memoryweave/graph.db"
|
||||
}
|
||||
patternStore := pattern.NewGraphPatternStore(graphPath)
|
||||
patternProvider := pattern.NewPatternProvider(patternStore, pattern.NewEmbedderProvider(emb))
|
||||
patternAPI := routes.NewPatternAPI(patternStore, patternProvider, func() storage.LanceDB { return ldb })
|
||||
if os.Getenv("ZHIYI_PATTERN_RECALL") == "1" {
|
||||
storage.PatternRecallProvider = patternProvider.Match
|
||||
log.Printf("[zhiyid] L2 模式召回注入已启用(ZHIYI_PATTERN_RECALL=1)")
|
||||
} else {
|
||||
log.Printf("[zhiyid] L2 模式召回注入默认关(ZHIYI_PATTERN_RECALL 未设/≠1 ⇒ 零行为变化)")
|
||||
}
|
||||
|
||||
// Obsidian
|
||||
obsidian := routes.NewObsidianSyncer("", ldb)
|
||||
|
||||
@@ -1068,6 +1089,9 @@ func NewServer() http.Handler {
|
||||
// 缺口
|
||||
mux.HandleFunc("/api/v1/gaps", gapAPI.List)
|
||||
mux.HandleFunc("/api/v1/gaps/detect", gapAPI.Detect)
|
||||
// t_d32e5f8a L2 模式检测(MemOS 血统)
|
||||
mux.HandleFunc("/api/v1/patterns", patternAPI.List)
|
||||
mux.HandleFunc("/api/v1/patterns/detect", patternAPI.Detect)
|
||||
mux.HandleFunc("/api/v1/gaps/close/", func(w http.ResponseWriter, r *http.Request) {
|
||||
gapAPI.Close(w, r)
|
||||
topic := r.URL.Path[len("/api/v1/gaps/close/"):]
|
||||
|
||||
@@ -0,0 +1,449 @@
|
||||
// 织忆 MemoryWeave — L2 模式检测引擎(t_d32e5f8a)
|
||||
//
|
||||
// 背景:MemOS 血统的 L2「跨任务重复模式」检测。原实现活在 Python daemon 的
|
||||
// main_loop(30s tick),2026-09-24 为 state-db 写安全整体退役后 L2 pattern 蒸馏
|
||||
// 停摆(graph_nodes type='pattern' 停在 85 个 / 2026-09-18)。本包把 L1→L2 蒸馏
|
||||
// 复活成**短命单发**(modernc sqlite 直连 graph.db,开/关不占长连接,不碰 state.db),
|
||||
// 并按设计 §4.1 叠加两条检测规则:
|
||||
// - 工具组合频率:同一 tool 组合出现 ≥3 次 → tool_combo pattern
|
||||
// (confidence = min(freq*0.1, 1.0))
|
||||
// - 相似解决路径聚类:cosine ≥0.85 成簇且簇内 ≥3 条 → workflow pattern
|
||||
//
|
||||
// 存储:复用现有 graph_nodes(type='pattern'),**不另开新表**(避免与 85 存量 + 现有
|
||||
// 图谱查询割裂)。namespace='daemon-distill' 沿用旧 daemon 约定。
|
||||
package pattern
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"math"
|
||||
"sort"
|
||||
"strings"
|
||||
|
||||
"github.com/xiaoxue/memoryweave/internal/models"
|
||||
)
|
||||
|
||||
// Pattern 一个被检测出的 L2 模式。
|
||||
type Pattern struct {
|
||||
ID string
|
||||
Type string // "tool_combo" | "workflow"
|
||||
Name string // 稳定命名键(同组合去重)
|
||||
Data string // tool_combo=排序后工具串;workflow=共同步骤/代表路径摘要
|
||||
Confidence float64
|
||||
SourceTasks []string // 支撑该 pattern 的记忆 ID(设计 source_tasks)
|
||||
Tools []string // tool_combo 专用
|
||||
}
|
||||
|
||||
// Config 检测参数(设计 §4.1)。
|
||||
type Config struct {
|
||||
MinComboFreq int // 工具组合出现 ≥ N 次才产 pattern(默认 3)
|
||||
ClusterThresh float64 // 相似路径聚类 cosine 阈值(默认 0.85)
|
||||
MinClusterSize int // 簇内 ≥ N 条才产 workflow pattern(默认 3)
|
||||
MaxRecords int // 单次扫描参与检测的记忆上限(防 O(n²) 爆炸,默认 500)
|
||||
TopKPatternList int // 召回/列出取前 N(默认 10)
|
||||
}
|
||||
|
||||
// DefaultConfig 设计参数。
|
||||
func DefaultConfig() Config {
|
||||
return Config{
|
||||
MinComboFreq: 3,
|
||||
ClusterThresh: 0.85,
|
||||
MinClusterSize: 3,
|
||||
MaxRecords: 500,
|
||||
TopKPatternList: 10,
|
||||
}
|
||||
}
|
||||
|
||||
// knownTools 常见工具/CLI/命令名(小写)。工具组合频率分析从这里识别 + 兜底正则。
|
||||
var knownTools = map[string]bool{
|
||||
"jq": true, "yq": true, "git": true, "grep": true, "sed": true, "awk": true,
|
||||
"curl": true, "wget": true, "tar": true, "zip": true, "unzip": true,
|
||||
"docker": true, "kubectl": true, "helm": true, "npm": true, "pip": true,
|
||||
"go": true, "python": true, "python3": true, "node": true, "pnpm": true,
|
||||
"make": true, "cmake": true, "gcc": true, "gcc-12": true, "clang": true,
|
||||
"sqlite3": true, "psql": true, "mysql": true, "redis-cli": true,
|
||||
"ssh": true, "scp": true, "rsync": true, "systemctl": true, "journalctl": true,
|
||||
"systemd-run": true, "crontab": true, "find": true, "rg": true, "ripgrep": true,
|
||||
"fd": true, "fzf": true, "gh": true, "gcloud": true, "aws": true, "jq2": true,
|
||||
"hermes": true, "zhiyi": true, "obsidian": true, "esbuild": true, "ts": true,
|
||||
"tsc": true, "cargo": true, "rustc": true, "swift": true, "brew": true,
|
||||
}
|
||||
|
||||
// DetectFromRecords 纯检测核心:从 L1 记忆列表发现重复模式。
|
||||
// 不读 LanceDB / 不写库,只做「记录 → pattern 候选」,便于确定性单测。
|
||||
// 返回合并去重后的 pattern 列表(同 Name 合并 source_tasks、取更高 confidence)。
|
||||
func DetectFromRecords(records []models.MemoryRecord, cfg Config) []Pattern {
|
||||
if cfg.MinComboFreq <= 0 {
|
||||
cfg.MinComboFreq = 3
|
||||
}
|
||||
if cfg.MinClusterSize <= 0 {
|
||||
cfg.MinClusterSize = 3
|
||||
}
|
||||
if cfg.ClusterThresh <= 0 {
|
||||
cfg.ClusterThresh = 0.85
|
||||
}
|
||||
lim := cfg.MaxRecords
|
||||
if lim <= 0 {
|
||||
lim = 500
|
||||
}
|
||||
if len(records) > lim {
|
||||
records = records[:lim]
|
||||
}
|
||||
|
||||
combined := make(map[string]*Pattern) // Name → merged pattern
|
||||
order := []string{}
|
||||
|
||||
merge := func(p Pattern) {
|
||||
if ex, ok := combined[p.Name]; ok {
|
||||
ex.SourceTasks = append(ex.SourceTasks, p.SourceTasks...)
|
||||
if p.Confidence > ex.Confidence {
|
||||
ex.Confidence = p.Confidence
|
||||
}
|
||||
return
|
||||
}
|
||||
combined[p.Name] = &p
|
||||
order = append(order, p.Name)
|
||||
}
|
||||
|
||||
// 1. 工具组合频率分析
|
||||
comboCount := map[string]*struct {
|
||||
tools []string
|
||||
tasks []string
|
||||
}{}
|
||||
for _, rec := range records {
|
||||
tools := ExtractTools(rec.Content)
|
||||
if len(tools) == 0 {
|
||||
continue
|
||||
}
|
||||
tools = dedupeSorted(tools)
|
||||
key := "tool_combo:" + strings.Join(tools, "+")
|
||||
c := comboCount[key]
|
||||
if c == nil {
|
||||
c = &struct {
|
||||
tools []string
|
||||
tasks []string
|
||||
}{tools: tools}
|
||||
comboCount[key] = c
|
||||
}
|
||||
c.tasks = append(c.tasks, rec.ID)
|
||||
}
|
||||
for name, c := range comboCount {
|
||||
if len(c.tasks) < cfg.MinComboFreq {
|
||||
continue
|
||||
}
|
||||
merge(Pattern{
|
||||
Type: "tool_combo",
|
||||
Name: name,
|
||||
Data: strings.Join(c.tools, "+"),
|
||||
Tools: c.tools,
|
||||
Confidence: confidenceFromFreq(len(c.tasks)),
|
||||
SourceTasks: c.tasks,
|
||||
})
|
||||
}
|
||||
|
||||
// 2. 相似解决路径聚类(cosine ≥ 阈值 成簇,簇内 ≥ N 条)
|
||||
paths := clusterPaths(records, cfg.ClusterThresh, cfg.MinClusterSize)
|
||||
for _, cluster := range paths {
|
||||
// 代表路径 = 簇内最长 content(共同步骤近似)
|
||||
rep := ""
|
||||
var ids []string
|
||||
for _, r := range cluster {
|
||||
ids = append(ids, r.ID)
|
||||
if len(r.Content) > len(rep) {
|
||||
rep = r.Content
|
||||
}
|
||||
}
|
||||
conf := clusterConfidence(cluster) // 平均两两 cosine,封顶 1.0
|
||||
if conf > 1.0 {
|
||||
conf = 1.0
|
||||
}
|
||||
// 簇名带代表内容哈希前 8 位 —— 同 size 不同内容簇不碰撞(否则 cluster-3 撞簇)
|
||||
name := fmt.Sprintf("workflow:cluster-%d-%s", len(cluster), contentFingerprint(rep))
|
||||
merge(Pattern{
|
||||
Type: "workflow",
|
||||
Name: name,
|
||||
Data: truncateForPattern(rep, 120),
|
||||
Confidence: conf,
|
||||
SourceTasks: ids,
|
||||
})
|
||||
}
|
||||
|
||||
out := make([]Pattern, 0, len(order))
|
||||
for _, n := range order {
|
||||
p := *combined[n]
|
||||
p.SourceTasks = dedupeStrings(p.SourceTasks)
|
||||
if p.Type == "tool_combo" {
|
||||
p.ID = "pat_" + p.Name
|
||||
} else {
|
||||
p.ID = "pat_" + p.Name
|
||||
}
|
||||
out = append(out, p)
|
||||
}
|
||||
sort.SliceStable(out, func(i, j int) bool {
|
||||
if out[i].Type != out[j].Type {
|
||||
return out[i].Type < out[j].Type
|
||||
}
|
||||
return out[i].Name < out[j].Name
|
||||
})
|
||||
return out
|
||||
}
|
||||
|
||||
// confidenceFromFreq 设计公式:min(freq*0.1, 1.0)。
|
||||
func confidenceFromFreq(freq int) float64 {
|
||||
c := float64(freq) * 0.1
|
||||
if c > 1.0 {
|
||||
c = 1.0
|
||||
}
|
||||
return c
|
||||
}
|
||||
|
||||
// clusterPaths 贪心成簇:为每条未分配记忆开一个簇,把与其 cosine≥阈值 的其余未分配
|
||||
// 记忆并入;最终只保留 size≥minSize 的簇。向量缺失时用记录自带 Vector,全缺则退到
|
||||
// 文本 bigram Jaccard(确定性,不依赖网络)。
|
||||
func clusterPaths(records []models.MemoryRecord, thresh float64, minSize int) [][]models.MemoryRecord {
|
||||
n := len(records)
|
||||
if n < minSize {
|
||||
return nil
|
||||
}
|
||||
type sig struct {
|
||||
vec []float32
|
||||
big map[string]bool
|
||||
text string
|
||||
}
|
||||
sigs := make([]sig, n)
|
||||
for i, r := range records {
|
||||
sigs[i] = sig{vec: r.Vector, text: r.Content}
|
||||
}
|
||||
sim := func(a, b int) float64 {
|
||||
sa, sb := sigs[a], sigs[b]
|
||||
if len(sa.vec) > 0 && len(sb.vec) > 0 {
|
||||
return cosineF32(sa.vec, sb.vec)
|
||||
}
|
||||
if len(sa.vec) == 0 && len(sb.vec) == 0 {
|
||||
return bigramJaccard(sa.text, sb.text)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
assigned := make([]bool, n)
|
||||
var clusters [][]models.MemoryRecord
|
||||
for i := 0; i < n; i++ {
|
||||
if assigned[i] {
|
||||
continue
|
||||
}
|
||||
cluster := []models.MemoryRecord{records[i]}
|
||||
assigned[i] = true
|
||||
for j := i + 1; j < n; j++ {
|
||||
if assigned[j] {
|
||||
continue
|
||||
}
|
||||
if sim(i, j) >= thresh {
|
||||
cluster = append(cluster, records[j])
|
||||
assigned[j] = true
|
||||
}
|
||||
}
|
||||
if len(cluster) >= minSize {
|
||||
clusters = append(clusters, cluster)
|
||||
}
|
||||
}
|
||||
return clusters
|
||||
}
|
||||
|
||||
// clusterConfidence 簇内平均两两相似度(cosine 或 Jaccard)。
|
||||
func clusterConfidence(cluster []models.MemoryRecord) float64 {
|
||||
n := len(cluster)
|
||||
if n < 2 {
|
||||
return 1.0
|
||||
}
|
||||
sum := 0.0
|
||||
pairs := 0
|
||||
for i := 0; i < n; i++ {
|
||||
for j := i + 1; j < n; j++ {
|
||||
var s float64
|
||||
a, b := cluster[i], cluster[j]
|
||||
if len(a.Vector) > 0 && len(b.Vector) > 0 {
|
||||
s = cosineF32(a.Vector, b.Vector)
|
||||
} else {
|
||||
s = bigramJaccard(a.Content, b.Content)
|
||||
}
|
||||
sum += s
|
||||
pairs++
|
||||
}
|
||||
}
|
||||
if pairs == 0 {
|
||||
return 1.0
|
||||
}
|
||||
return sum / float64(pairs)
|
||||
}
|
||||
|
||||
// ExtractTools 从记忆内容提取工具/命令名。识别 knownTools + 兜底 ascii token。
|
||||
// 确定性:结果排序去重。
|
||||
func ExtractTools(content string) []string {
|
||||
found := map[string]bool{}
|
||||
lower := strings.ToLower(content)
|
||||
for t := range knownTools {
|
||||
// 词边界匹配(避免 "go" 命中 "google")
|
||||
if tokenPresent(lower, t) {
|
||||
found[t] = true
|
||||
}
|
||||
}
|
||||
// 兜底:捕获已知列表外的 ascii 命令式 token(2~14 字符,含 - 的命令风格)
|
||||
for _, tok := range regexTokenExtract(content) {
|
||||
lt := strings.ToLower(tok)
|
||||
if len(lt) < 2 {
|
||||
continue
|
||||
}
|
||||
// 排除明显非工具的常见词(纯小写短词且不在 knownTools 的放行——保持宽松,
|
||||
// 让工具组合信号进来;过噪由 MinComboFreq 过滤)
|
||||
found[lt] = true
|
||||
}
|
||||
out := make([]string, 0, len(found))
|
||||
for t := range found {
|
||||
out = append(out, t)
|
||||
}
|
||||
sort.Strings(out)
|
||||
return out
|
||||
}
|
||||
|
||||
// tokenPresent 检查 lower 文本中 t 是否作为独立 token 出现(词边界,避免 "go" 命中 "google")。
|
||||
func tokenPresent(lower, t string) bool {
|
||||
if t == "" {
|
||||
return false
|
||||
}
|
||||
// 切词精确匹配
|
||||
for _, w := range strings.Fields(lower) {
|
||||
// 剥掉包裹的引号/逗号/括号
|
||||
w = strings.Trim(w, `"',()[]|;:`)
|
||||
if w == t {
|
||||
return true
|
||||
}
|
||||
}
|
||||
// 空格/首尾边界
|
||||
if strings.Contains(lower, " "+t+" ") || strings.HasPrefix(lower, t+" ") || strings.HasSuffix(lower, " "+t) {
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// regexTokenExtract 轻量 token 抽取(无正则依赖,按字符切):
|
||||
// 返回形如命令/token 的 ascii 串(长度 ≥2,含字母,可能带数字/_.-)。
|
||||
func regexTokenExtract(content string) []string {
|
||||
var out []string
|
||||
var cur []rune
|
||||
flush := func() {
|
||||
if len(cur) >= 2 {
|
||||
out = append(out, string(cur))
|
||||
}
|
||||
cur = nil
|
||||
}
|
||||
for _, r := range content {
|
||||
isTok := (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') ||
|
||||
(r >= '0' && r <= '9') || r == '_' || r == '-' || r == '.'
|
||||
if isTok {
|
||||
cur = append(cur, r)
|
||||
} else {
|
||||
flush()
|
||||
}
|
||||
}
|
||||
flush()
|
||||
return out
|
||||
}
|
||||
|
||||
func dedupeSorted(in []string) []string {
|
||||
seen := map[string]bool{}
|
||||
out := make([]string, 0, len(in))
|
||||
for _, s := range in {
|
||||
if !seen[s] {
|
||||
seen[s] = true
|
||||
out = append(out, s)
|
||||
}
|
||||
}
|
||||
sort.Strings(out)
|
||||
return out
|
||||
}
|
||||
|
||||
func dedupeStrings(in []string) []string {
|
||||
seen := map[string]bool{}
|
||||
out := make([]string, 0, len(in))
|
||||
for _, s := range in {
|
||||
if !seen[s] {
|
||||
seen[s] = true
|
||||
out = append(out, s)
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func cosineF32(a, b []float32) float64 {
|
||||
if len(a) == 0 || len(b) == 0 || len(a) != len(b) {
|
||||
return 0
|
||||
}
|
||||
var dot, na, nb float64
|
||||
for i := range a {
|
||||
x, y := float64(a[i]), float64(b[i])
|
||||
dot += x * y
|
||||
na += x * x
|
||||
nb += y * y
|
||||
}
|
||||
if na == 0 || nb == 0 {
|
||||
return 0
|
||||
}
|
||||
c := dot / (float64(math.Sqrt(na)) * float64(math.Sqrt(nb)))
|
||||
if c > 1.0 {
|
||||
c = 1.0
|
||||
}
|
||||
if c < -1.0 {
|
||||
c = -1.0
|
||||
}
|
||||
return c
|
||||
}
|
||||
|
||||
// bigramJaccard 字符 bigram Jaccard 相似度(无向量时的确定性回退)。
|
||||
func bigramJaccard(a, b string) float64 {
|
||||
bg := func(s string) map[string]bool {
|
||||
m := make(map[string]bool)
|
||||
r := []rune(s)
|
||||
for i := 0; i+1 < len(r); i++ {
|
||||
m[string(r[i:i+2])] = true
|
||||
}
|
||||
return m
|
||||
}
|
||||
ma, mb := bg(a), bg(b)
|
||||
if len(ma) == 0 && len(mb) == 0 {
|
||||
return 1.0
|
||||
}
|
||||
if len(ma) == 0 || len(mb) == 0 {
|
||||
return 0.0
|
||||
}
|
||||
inter := 0
|
||||
for k := range ma {
|
||||
if mb[k] {
|
||||
inter++
|
||||
}
|
||||
}
|
||||
uni := len(ma) + len(mb) - inter
|
||||
if uni == 0 {
|
||||
return 0
|
||||
}
|
||||
return float64(inter) / float64(uni)
|
||||
}
|
||||
|
||||
// contentFingerprint 取 content 稳定短指纹(FNV 前 8 hex 位)——同 size 不同内容簇去重。
|
||||
func contentFingerprint(s string) string {
|
||||
if s == "" {
|
||||
return "empty"
|
||||
}
|
||||
// FNV-1a 32
|
||||
h := uint32(2166136261)
|
||||
for i := 0; i < len(s); i++ {
|
||||
h ^= uint32(s[i])
|
||||
h *= 16777619
|
||||
}
|
||||
return fmt.Sprintf("%08x", h)
|
||||
}
|
||||
|
||||
func truncateForPattern(s string, n int) string {
|
||||
r := []rune(s)
|
||||
if len(r) <= n {
|
||||
return s
|
||||
}
|
||||
return string(r[:n]) + "…"
|
||||
}
|
||||
@@ -0,0 +1,111 @@
|
||||
package pattern
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/xiaoxue/memoryweave/internal/models"
|
||||
)
|
||||
|
||||
// 构造 N 条同一工具组合的记忆(内容里带 jq/git/curl 三个已知工具)。
|
||||
func comboRecords(n int, combo string) []models.MemoryRecord {
|
||||
// combo 形如 "jq git curl"——内容里出现这三个工具名(空格分隔,保证词边界命中)。
|
||||
// 上下文用纯中文(非 ascii token),避免回退正则把上下文词误当工具混进组合键。
|
||||
recs := make([]models.MemoryRecord, 0, n)
|
||||
for i := 0; i < n; i++ {
|
||||
recs = append(recs, models.MemoryRecord{
|
||||
ID: "m_" + string(rune('a'+i)),
|
||||
Content: "用 " + combo + " 处理第" + string(rune('一'+i)) + "项",
|
||||
Category: "distilled",
|
||||
Vector: nil, // 走 bigram Jaccard 回退(确定性,不依赖网络)
|
||||
})
|
||||
}
|
||||
return recs
|
||||
}
|
||||
|
||||
// TestDetect_ToolCombo —— 3 条同工具组合记忆 → 检出 1 个 tool_combo pattern(AC2)。
|
||||
func TestDetect_ToolCombo(t *testing.T) {
|
||||
recs := comboRecords(3, "jq git curl")
|
||||
pats := DetectFromRecords(recs, DefaultConfig())
|
||||
var toolPatterns []Pattern
|
||||
for _, p := range pats {
|
||||
if p.Type == "tool_combo" {
|
||||
toolPatterns = append(toolPatterns, p)
|
||||
}
|
||||
}
|
||||
if len(toolPatterns) != 1 {
|
||||
t.Fatalf("期望 1 个 tool_combo pattern,实际 %d: %#v", len(toolPatterns), toolPatterns)
|
||||
}
|
||||
p := toolPatterns[0]
|
||||
if p.Name != "tool_combo:curl+git+jq" {
|
||||
t.Fatalf("命名键不符: got %q (工具应排序去重为 curl,git,jq)", p.Name)
|
||||
}
|
||||
if len(p.Tools) != 3 {
|
||||
t.Fatalf("Tools 应含 3 个,实际 %v", p.Tools)
|
||||
}
|
||||
// confidence = min(freq*0.1,1.0) = min(3*0.1,1.0) ≈ 0.3(浮点容差 1e-9)
|
||||
if p.Confidence < 0.3-1e-9 || p.Confidence > 0.3+1e-9 {
|
||||
t.Fatalf("confidence 期望 ≈0.3,实际 %f", p.Confidence)
|
||||
}
|
||||
if len(p.SourceTasks) != 3 {
|
||||
t.Fatalf("SourceTasks 应含 3 条记忆 ID,实际 %v", p.SourceTasks)
|
||||
}
|
||||
}
|
||||
|
||||
// TestDetect_BelowThreshold —— 2 条同组合(<3)→ 不产 tool_combo(AC2 反例)。
|
||||
func TestDetect_BelowThreshold(t *testing.T) {
|
||||
recs := comboRecords(2, "jq git curl")
|
||||
pats := DetectFromRecords(recs, DefaultConfig())
|
||||
for _, p := range pats {
|
||||
if p.Type == "tool_combo" {
|
||||
t.Fatalf("2 条同组合不应产 tool_combo,实际产出: %#v", p)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestDetect_Workflow —— 3 条近同文(向量近似 1.0 或 bigram 高度重合)→ 1 个 workflow 簇。
|
||||
func TestDetect_Workflow(t *testing.T) {
|
||||
// 向量相同(cosine=1.0 ≥ 0.85)且 3 条 → 应聚成 1 簇。
|
||||
vec := []float32{1.0, 0.0, 0.0, 0.0}
|
||||
recs := []models.MemoryRecord{
|
||||
{ID: "w1", Content: "重启服务后拉日志", Category: "distilled", Vector: vec},
|
||||
{ID: "w2", Content: "重启服务后拉日志", Category: "distilled", Vector: vec},
|
||||
{ID: "w3", Content: "重启服务后拉日志", Category: "distilled", Vector: vec},
|
||||
}
|
||||
pats := DetectFromRecords(recs, DefaultConfig())
|
||||
var wf []Pattern
|
||||
for _, p := range pats {
|
||||
if p.Type == "workflow" {
|
||||
wf = append(wf, p)
|
||||
}
|
||||
}
|
||||
if len(wf) != 1 {
|
||||
t.Fatalf("3 条近同文应聚 1 个 workflow pattern,实际 %d: %#v", len(wf), pats)
|
||||
}
|
||||
if !strings.HasPrefix(wf[0].Name, "workflow:cluster-3-") {
|
||||
t.Fatalf("workflow 命名应含 cluster-3-<fp>,实际 %q", wf[0].Name)
|
||||
}
|
||||
}
|
||||
|
||||
// TestDetect_Empty —— 空输入 → 空输出不报错(AC1 空库前提)。
|
||||
func TestDetect_Empty(t *testing.T) {
|
||||
if pats := DetectFromRecords(nil, DefaultConfig()); len(pats) != 0 {
|
||||
t.Fatalf("空输入应 0 pattern,实际 %d", len(pats))
|
||||
}
|
||||
}
|
||||
|
||||
// TestExtractTools —— 词边界:「google」不应命中工具 "go"。
|
||||
func TestExtractTools_WordBoundary(t *testing.T) {
|
||||
tools := ExtractTools("I like google and grep the log with jq")
|
||||
// 应含 grep、jq;不应含 go("google" 被词边界排除)
|
||||
found := map[string]bool{}
|
||||
for _, s := range tools {
|
||||
found[s] = true
|
||||
}
|
||||
if !found["grep"] || !found["jq"] {
|
||||
t.Fatalf("应识别 grep/jq,实际 %v", tools)
|
||||
}
|
||||
if found["go"] {
|
||||
t.Fatalf("'google' 误命中工具 'go'(词边界失效): %v", tools)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,138 @@
|
||||
// 织忆 MemoryWeave — L2 pattern 召回 Provider(t_d32e5f8a)
|
||||
//
|
||||
// 把 graph_nodes(type='pattern') 变成召回可附带的 pattern 命中(设计 §4.1「命中即注入」)。
|
||||
// 匹配语义:query 编码成向量 → 对每个 pattern 取「代表向量」(pattern.data 文本的 embedding)
|
||||
// 算 cosine,取 ≥ 阈值 的前 topK。embedder 不可用 / 无 pattern 时返回空(不报错、零注入)。
|
||||
//
|
||||
// 与 storage.PatternRecallProvider 解耦:本 Provider 是纯函数式匹配器,
|
||||
// server.go 把它包进 storage.PatternRecallProvider 闭包(再叠 env 门控)。
|
||||
package pattern
|
||||
|
||||
import (
|
||||
"log"
|
||||
"strings"
|
||||
|
||||
"github.com/xiaoxue/memoryweave/internal/models"
|
||||
)
|
||||
|
||||
// EmbedderProvider pattern 文本 → 向量。复用 storage.Embedder.EncodeSingle 语义。
|
||||
type EmbedderProvider interface {
|
||||
Embed(text string) ([]float32, error)
|
||||
}
|
||||
|
||||
// StorageEmbedderAdapter 把 storage.Embedder(EncodeSingle)适配成 EmbedderProvider,
|
||||
// 供 server.go 装配 pattern.Provider 用(pattern 包不 import storage,避免循环依赖)。
|
||||
type StorageEmbedderAdapter interface {
|
||||
EncodeSingle(text string) ([]float32, error)
|
||||
}
|
||||
|
||||
// adapterProvider 实现 EmbedderProvider。
|
||||
type adapterProvider struct {
|
||||
inner StorageEmbedderAdapter
|
||||
}
|
||||
|
||||
func (a adapterProvider) Embed(text string) ([]float32, error) {
|
||||
return a.inner.EncodeSingle(text)
|
||||
}
|
||||
|
||||
// NewEmbedderProvider 从 storage.Embedder 适配(签名匹配 EncodeSingle)。
|
||||
func NewEmbedderProvider(inner StorageEmbedderAdapter) EmbedderProvider {
|
||||
return adapterProvider{inner: inner}
|
||||
}
|
||||
|
||||
// recallProvider storage 侧注入用的适配签名实现(包一层)。
|
||||
// 与 recall.go 的 PatternRecallProvider 保持解耦:pattern 包不 import storage(避免循环)。
|
||||
|
||||
// PatternProvider 匹配器:query+namespace → top-k pattern(转成 RecallResult,Category="pattern")。
|
||||
type PatternProvider struct {
|
||||
store *GraphPatternStore
|
||||
embedder EmbedderProvider
|
||||
threshold float64 // 相似度下限(默认 0.6;低于则不注入,避免噪声 pattern)
|
||||
}
|
||||
|
||||
// NewPatternProvider 构造匹配器。store 读 graph_nodes(type='pattern')。
|
||||
func NewPatternProvider(store *GraphPatternStore, emb EmbedderProvider) *PatternProvider {
|
||||
return &PatternProvider{store: store, embedder: emb, threshold: 0.6}
|
||||
}
|
||||
|
||||
// SetThreshold 调整相似度下限。
|
||||
func (pp *PatternProvider) SetThreshold(t float64) { pp.threshold = t }
|
||||
|
||||
// Match query+namespace → 命中的 pattern(top-k,cosine≥threshold)。
|
||||
// 返回 models.RecallResult(Category="pattern",Content=pattern 摘要),
|
||||
// 供 storage.PatternRecallProvider 直接附带到召回结果。
|
||||
func (pp *PatternProvider) Match(query, namespace string, topK int) []models.RecallResult {
|
||||
if pp == nil || pp.store == nil || topK <= 0 {
|
||||
return nil
|
||||
}
|
||||
pats, err := pp.store.ListPatterns(topK * 3) // 多取些再按相似度截断
|
||||
if err != nil || len(pats) == 0 {
|
||||
return nil
|
||||
}
|
||||
qv, err := pp.embedder.Embed(query)
|
||||
if err != nil || len(qv) == 0 {
|
||||
log.Printf("[pattern-recall] query 编码失败,跳过注入: %v", err)
|
||||
return nil
|
||||
}
|
||||
type scored struct {
|
||||
p Pattern
|
||||
sim float64
|
||||
}
|
||||
var scoredList []scored
|
||||
for _, p := range pats {
|
||||
// namespace 过滤:daemon-distill 是跨 ns 的,namespace 非空时仍保留(pattern 全局复用)
|
||||
rep := p.Data
|
||||
if rep == "" {
|
||||
rep = p.Name
|
||||
}
|
||||
// 加 query 里出现的工具名做召回加权(工具组合 pattern 对工具词敏感)
|
||||
text := rep + " " + strings.Join(p.Tools, " ")
|
||||
pv, err := pp.embedder.Embed(text)
|
||||
if err != nil || len(pv) == 0 {
|
||||
continue
|
||||
}
|
||||
sim := cosineF32(qv, pv)
|
||||
// 工具词命中加成:query 含 pattern 任一工具 ⇒ sim 抬 0.15
|
||||
qLower := strings.ToLower(query)
|
||||
for _, tool := range p.Tools {
|
||||
if tool != "" && strings.Contains(qLower, strings.ToLower(tool)) {
|
||||
sim += 0.15
|
||||
break
|
||||
}
|
||||
}
|
||||
if sim > 1.0 {
|
||||
sim = 1.0
|
||||
}
|
||||
if sim >= pp.threshold {
|
||||
scoredList = append(scoredList, scored{p: p, sim: sim})
|
||||
}
|
||||
}
|
||||
// 按 sim 降序取 topK
|
||||
if len(scoredList) > topK {
|
||||
// 简单选择:O(n^2) 但 n 很小
|
||||
for i := 0; i < len(scoredList); i++ {
|
||||
for j := i + 1; j < len(scoredList); j++ {
|
||||
if scoredList[j].sim > scoredList[i].sim {
|
||||
scoredList[i], scoredList[j] = scoredList[j], scoredList[i]
|
||||
}
|
||||
}
|
||||
}
|
||||
scoredList = scoredList[:topK]
|
||||
}
|
||||
out := make([]models.RecallResult, 0, len(scoredList))
|
||||
for _, sc := range scoredList {
|
||||
content := sc.p.Name
|
||||
if sc.p.Data != "" {
|
||||
content = sc.p.Name + " — " + sc.p.Data
|
||||
}
|
||||
out = append(out, models.RecallResult{
|
||||
ID: sc.p.ID,
|
||||
Content: content,
|
||||
Category: "pattern",
|
||||
Score: sc.sim,
|
||||
Namespace: namespace,
|
||||
Source: "l2_pattern",
|
||||
})
|
||||
}
|
||||
return out
|
||||
}
|
||||
@@ -0,0 +1,255 @@
|
||||
// 织忆 MemoryWeave — L2 pattern 存储(t_d32e5f8a)
|
||||
//
|
||||
// 存储沿用现有 graph_nodes(type='pattern'),**不另开新表**(避免与 85 存量 +
|
||||
// 现有图谱查询割裂)。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
|
||||
}
|
||||
|
||||
// ListPatterns 列出 graph_nodes(type='pattern'),按 occurrence_count 降序取 top N。
|
||||
// 0 / 空库 → 空列表不报错(AC1)。
|
||||
func (s *GraphPatternStore) ListPatterns(limit int) ([]Pattern, error) {
|
||||
if limit <= 0 {
|
||||
limit = 10
|
||||
}
|
||||
db, oerr := s.open()
|
||||
if oerr != nil {
|
||||
return nil, oerr
|
||||
}
|
||||
rows, qerr := db.Query(`SELECT id, name, properties FROM graph_nodes WHERE type='pattern' LIMIT ?`, limit*3)
|
||||
if qerr != nil {
|
||||
return nil, qerr
|
||||
}
|
||||
defer rows.Close()
|
||||
type raw struct {
|
||||
ID, Name, Props string
|
||||
}
|
||||
var all []raw
|
||||
for rows.Next() {
|
||||
var r raw
|
||||
if serr := rows.Scan(&r.ID, &r.Name, &r.Props); serr != nil {
|
||||
return nil, serr
|
||||
}
|
||||
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 o, ok := props["occurrence_count"].(float64); ok {
|
||||
_ = o
|
||||
}
|
||||
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)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
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, nil
|
||||
}
|
||||
@@ -0,0 +1,116 @@
|
||||
package pattern
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"testing"
|
||||
|
||||
_ "modernc.org/sqlite"
|
||||
)
|
||||
|
||||
// newTestStore 指向 t.TempDir() 的空库(modernc 纯 Go,无需 CGO/网络)。
|
||||
func newTestStore(t *testing.T) *GraphPatternStore {
|
||||
t.Helper()
|
||||
dir := t.TempDir()
|
||||
s := NewGraphPatternStore(dir + "/graph.db")
|
||||
t.Cleanup(s.Close)
|
||||
return s
|
||||
}
|
||||
|
||||
// TestStore_EmptyList —— 空库 ListPatterns → 0 条不报错(AC1 判据:SELECT count ≥0 不报错)。
|
||||
func TestStore_EmptyList(t *testing.T) {
|
||||
s := newTestStore(t)
|
||||
got, err := s.ListPatterns(10)
|
||||
if err != nil {
|
||||
t.Fatalf("空库 List 不应报错: %v", err)
|
||||
}
|
||||
if len(got) != 0 {
|
||||
t.Fatalf("空库应 0 条 pattern,实际 %d", len(got))
|
||||
}
|
||||
}
|
||||
|
||||
// TestStore_UpsertEmpty —— 空输入 Upsert → 0,0,nil(AC1 判据)。
|
||||
func TestStore_UpsertEmpty(t *testing.T) {
|
||||
s := newTestStore(t)
|
||||
created, updated, err := s.UpsertPatterns(nil)
|
||||
if err != nil {
|
||||
t.Fatalf("空输入 Upsert 不应报错: %v", err)
|
||||
}
|
||||
if created != 0 || updated != 0 {
|
||||
t.Fatalf("空输入应 0/0,实际 %d/%d", created, updated)
|
||||
}
|
||||
}
|
||||
|
||||
// TestStore_UpsertCreate —— 新 pattern → INSERT 1 条,occurrence_count=1(AC2 前置)。
|
||||
func TestStore_UpsertCreate(t *testing.T) {
|
||||
s := newTestStore(t)
|
||||
p := Pattern{
|
||||
ID: "pat_tool_combo:curl+git+jq",
|
||||
Type: "tool_combo",
|
||||
Name: "tool_combo:curl+git+jq",
|
||||
Data: "curl+git+jq",
|
||||
Confidence: 0.3,
|
||||
Tools: []string{"curl", "git", "jq"},
|
||||
SourceTasks: []string{"m_a", "m_b", "m_c"},
|
||||
}
|
||||
created, updated, err := s.UpsertPatterns([]Pattern{p})
|
||||
if err != nil {
|
||||
t.Fatalf("upsert 报错: %v", err)
|
||||
}
|
||||
if created != 1 || updated != 0 {
|
||||
t.Fatalf("新 pattern 应 created=1/updated=0,实际 %d/%d", created, updated)
|
||||
}
|
||||
listed, _ := s.ListPatterns(10)
|
||||
if len(listed) != 1 {
|
||||
t.Fatalf("应 1 条,实际 %d", len(listed))
|
||||
}
|
||||
}
|
||||
|
||||
// TestStore_UpsertIdempotent —— 同名 pattern 二次 upsert → updated=1、occurrence_count=2。
|
||||
// 验证幂等语义(occurrence_count 驱动,AC2 sqlite 查判据):跑两次检测,不产生重复行。
|
||||
func TestStore_UpsertIdempotent(t *testing.T) {
|
||||
s := newTestStore(t)
|
||||
p := Pattern{
|
||||
ID: "pat_tool_combo:curl+git+jq",
|
||||
Type: "tool_combo",
|
||||
Name: "tool_combo:curl+git+jq",
|
||||
Data: "curl+git+jq",
|
||||
Confidence: 0.3,
|
||||
Tools: []string{"curl", "git", "jq"},
|
||||
SourceTasks: []string{"m_a", "m_b", "m_c"},
|
||||
}
|
||||
c1, u1, _ := s.UpsertPatterns([]Pattern{p}) // 新建
|
||||
p.Confidence = 0.4 // 第二次检测:同组合再次出现(freq 抬升)
|
||||
p.SourceTasks = []string{"m_d"}
|
||||
c2, u2, _ := s.UpsertPatterns([]Pattern{p}) // 应幂等更新(updated=1)
|
||||
if c1 != 1 || u1 != 0 {
|
||||
t.Fatalf("首次应 created=1/updated=0,实际 %d/%d", c1, u1)
|
||||
}
|
||||
if c2 != 0 || u2 != 1 {
|
||||
t.Fatalf("二次应 created=0/updated=1,实际 %d/%d", c2, u2)
|
||||
}
|
||||
// 读库验:仍是 1 行、occurrence_count=2(幂等,非重复)
|
||||
db, err := sql.Open("sqlite", s.dbPath)
|
||||
if err != nil {
|
||||
t.Fatalf("open: %v", err)
|
||||
}
|
||||
defer db.Close()
|
||||
var (
|
||||
cnt int
|
||||
occ int
|
||||
)
|
||||
if err := db.QueryRow(`SELECT count(*) FROM graph_nodes WHERE type='pattern'`).Scan(&cnt); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if cnt != 1 {
|
||||
t.Fatalf("两次同 pattern 检测后应仍 1 行,实际 %d(幂等失败)", cnt)
|
||||
}
|
||||
var raw string
|
||||
_ = db.QueryRow(`SELECT properties FROM graph_nodes WHERE type='pattern'`).Scan(&raw)
|
||||
var props map[string]interface{}
|
||||
_ = json.Unmarshal([]byte(raw), &props)
|
||||
occ = int(props["occurrence_count"].(float64))
|
||||
if occ != 2 {
|
||||
t.Fatalf("occurrence_count 应累计到 2,实际 %d", occ)
|
||||
}
|
||||
}
|
||||
@@ -51,6 +51,23 @@ var (
|
||||
staleAfterHours = envFloat("ZHIYI_STALE_AFTER_HOURS", 0)
|
||||
)
|
||||
|
||||
// ── t_d32e5f8a L2 模式召回注入(env 门控 ZHIYI_PATTERN_RECALL,默认 0 ⇒ 行为零变化)──
|
||||
// Provider 由 server.go 装配:读 graph_nodes(type='pattern'),按 query/namespace 匹配
|
||||
// 出 top-k pattern,作为 Category="pattern" 的召回条目附带返回(设计 §4.1「命中即注入」)。
|
||||
// 未注册 Provider(默认 =0 时 server 不注册)⇒ 注入块整体跳过,召回结果逐条不变。
|
||||
// 注册了 Provider 但 ZHIYI_PATTERN_RECALL=0 ⇒ 同样跳过(关时零变化,AC3 判据)。
|
||||
var PatternRecallProvider func(query, namespace string, topK int) []models.RecallResult
|
||||
|
||||
// patternRecallEnabled 每次调用读 env(测试可 t.Setenv 翻转,无需重跑 init)。
|
||||
// 默认(未设)= 关闭。
|
||||
func patternRecallEnabled() bool {
|
||||
switch strings.ToLower(os.Getenv("ZHIYI_PATTERN_RECALL")) {
|
||||
case "1", "true", "on":
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func envFloat(key string, def float64) float64 {
|
||||
if v := os.Getenv(key); v != "" {
|
||||
if f, err := strconv.ParseFloat(v, 64); err == nil {
|
||||
@@ -522,6 +539,25 @@ func (p *RecallPipeline) recallUncached(query, namespace string, topK int, diver
|
||||
}
|
||||
results = deduped
|
||||
|
||||
// Step 6.2: t_d32e5f8a L2 模式召回注入(env 门控 ZHIYI_PATTERN_RECALL,默认 0)
|
||||
// 命中 pattern 时以 Category="pattern" 附带 top-k 返回(设计「命中即注入」)。
|
||||
// 默认关 ⇒ 整块跳过,results 逐条不变(AC3 判据:固定 query 前后 diff 为空)。
|
||||
if patternRecallEnabled() && PatternRecallProvider != nil {
|
||||
for _, pr := range PatternRecallProvider(query, namespace, 3) {
|
||||
// 去重:不重复追加已在结果里的条目
|
||||
dup := false
|
||||
for _, r := range results {
|
||||
if r.ID == pr.ID {
|
||||
dup = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !dup {
|
||||
results = append(results, pr)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Step 6.5: 写搜索缓存(§2.6 — t_1c12e000 起 TTL=60s,下次相同 query+topK+diversity
|
||||
// 直接返回;写路径落库后会 Invalidate 本 namespace,陈旧窗口上限=60s 双保险)
|
||||
if SearchCacheInstance != nil {
|
||||
|
||||
@@ -0,0 +1,146 @@
|
||||
package storage
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/xiaoxue/memoryweave/internal/models"
|
||||
)
|
||||
|
||||
// AC3/AC4:L2 模式召回注入(t_d32e5f8a)的开关行为测试。
|
||||
// 判据:
|
||||
// - 默认(ZHIYI_PATTERN_RECALL 未设/≠1)⇒ 即使注册了 Provider,召回结果也不变(零行为变化)
|
||||
// - =1 ⇒ 命中 pattern 的 query 召回结果含 Category="pattern" 条目
|
||||
|
||||
// patternRecallLance 返回固定 2 条记忆 + 记录 Search 实参(注入测试专用假后端)。
|
||||
type patternRecallLance struct {
|
||||
LanceDB
|
||||
rows []models.MemoryRecord
|
||||
}
|
||||
|
||||
func (f *patternRecallLance) Search(table string, vector []float32, topK int, namespaceFilter string) ([]models.MemoryRecord, error) {
|
||||
return f.rows, nil
|
||||
}
|
||||
func (f *patternRecallLance) Update(table, id string, fields map[string]any) error { return nil }
|
||||
|
||||
func newPatternRecallPipeline(t *testing.T) (*RecallPipeline, *patternRecallLance) {
|
||||
t.Helper()
|
||||
saved := SearchCacheInstance
|
||||
SearchCacheInstance = nil
|
||||
t.Cleanup(func() { SearchCacheInstance = saved })
|
||||
|
||||
fake := &patternRecallLance{rows: []models.MemoryRecord{
|
||||
{ID: "m_base1", Content: "蒸馏模型日限计数器跨天重置", Category: "distilled"},
|
||||
{ID: "m_base2", Content: "用 jq git curl 处理日志", Category: "distilled"},
|
||||
}}
|
||||
embsaved := VValueProvider
|
||||
t.Cleanup(func() { VValueProvider = embsaved })
|
||||
|
||||
vec := make([]float32, 1024)
|
||||
for i := range vec {
|
||||
vec[i] = 0.01
|
||||
}
|
||||
emb := &Embedder{endpoint: "http://127.0.0.1:1/never", dim: 1024}
|
||||
emb.cache.Store("pattern 注入测试", vec)
|
||||
p := NewRecallPipeline(emb, fake, &Reranker{})
|
||||
return p, fake
|
||||
}
|
||||
|
||||
// patternIDs 提取结果里 pattern 类条目 ID(判据:有无 Category="pattern")。
|
||||
func patternIDs(res []models.RecallResult) []string {
|
||||
var out []string
|
||||
for _, r := range res {
|
||||
if r.Category == "pattern" {
|
||||
out = append(out, r.ID)
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// TestPatternRecall_DefaultOff —— AC3:env 默认(未设)⇒ 注册了 Provider 也不注入,
|
||||
// 固定 query 召回前后 diff 为空(行为零变化)。
|
||||
func TestPatternRecall_DefaultOff(t *testing.T) {
|
||||
t.Setenv("ZHIYI_PATTERN_RECALL", "") // 清空(模拟未设)
|
||||
p, _ := newPatternRecallPipeline(t)
|
||||
|
||||
// 注册一个会注入 2 条 pattern 的 Provider
|
||||
saved := PatternRecallProvider
|
||||
PatternRecallProvider = func(query, namespace string, topK int) []models.RecallResult {
|
||||
return []models.RecallResult{
|
||||
{ID: "pat_x", Category: "pattern", Content: "tool_combo:curl+git+jq"},
|
||||
{ID: "pat_y", Category: "pattern", Content: "workflow:cluster-3-abcdef01"},
|
||||
}
|
||||
}
|
||||
t.Cleanup(func() { PatternRecallProvider = saved })
|
||||
|
||||
res, err := p.Recall("pattern 注入测试", "test-ns", 10, 0.0)
|
||||
if err != nil {
|
||||
t.Fatalf("recall 报错: %v", err)
|
||||
}
|
||||
if ids := patternIDs(res); len(ids) != 0 {
|
||||
t.Fatalf("ZHIYI_PATTERN_RECALL 默认关时不应注入 pattern,实际注入了 %v", ids)
|
||||
}
|
||||
// 固定 query 前后 diff:再跑一次(仍关),结果必须一致
|
||||
res2, _ := p.Recall("pattern 注入测试", "test-ns", 10, 0.0)
|
||||
if len(res) != len(res2) {
|
||||
t.Fatalf("关时两次召回结果数不一致: %d vs %d", len(res), len(res2))
|
||||
}
|
||||
}
|
||||
|
||||
// TestPatternRecall_On —— AC4:ZHIYI_PATTERN_RECALL=1 ⇒ 召回结果含 pattern 条目(前后对照)。
|
||||
func TestPatternRecall_On(t *testing.T) {
|
||||
t.Setenv("ZHIYI_PATTERN_RECALL", "1")
|
||||
p, _ := newPatternRecallPipeline(t)
|
||||
|
||||
// 关时(env 先置 0)无 pattern → 作为「前」
|
||||
t.Setenv("ZHIYI_PATTERN_RECALL", "0")
|
||||
saved := PatternRecallProvider
|
||||
PatternRecallProvider = func(query, namespace string, topK int) []models.RecallResult {
|
||||
return []models.RecallResult{
|
||||
{ID: "pat_hit", Category: "pattern", Content: "tool_combo:curl+git+jq"},
|
||||
}
|
||||
}
|
||||
t.Cleanup(func() { PatternRecallProvider = saved })
|
||||
|
||||
before, _ := p.Recall("pattern 注入测试", "test-ns", 10, 0.0)
|
||||
beforePat := patternIDs(before)
|
||||
|
||||
// 开时(env=1)应有 pattern → 作为「后」
|
||||
t.Setenv("ZHIYI_PATTERN_RECALL", "1")
|
||||
after, _ := p.Recall("pattern 注入测试", "test-ns", 10, 0.0)
|
||||
afterPat := patternIDs(after)
|
||||
|
||||
if len(beforePat) != 0 {
|
||||
t.Fatalf("env=0(前)应无 pattern 注入,实际 %v", beforePat)
|
||||
}
|
||||
if len(afterPat) == 0 {
|
||||
t.Fatalf("env=1(后)应注入 pattern,实际 %v", afterPat)
|
||||
}
|
||||
if afterPat[0] != "pat_hit" {
|
||||
t.Fatalf("pattern 条目 ID 不符: %v", afterPat)
|
||||
}
|
||||
}
|
||||
|
||||
// TestPatternRecall_Dedup —— 注入的 pattern ID 与既有结果重复时不重复追加。
|
||||
func TestPatternRecall_Dedup(t *testing.T) {
|
||||
t.Setenv("ZHIYI_PATTERN_RECALL", "1")
|
||||
p, _ := newPatternRecallPipeline(t)
|
||||
saved := PatternRecallProvider
|
||||
PatternRecallProvider = func(query, namespace string, topK int) []models.RecallResult {
|
||||
// 返回一个与既有结果同 ID 的条目(m_base1)—— 不应重复
|
||||
return []models.RecallResult{
|
||||
{ID: "m_base1", Category: "pattern", Content: "dup-check"},
|
||||
}
|
||||
}
|
||||
t.Cleanup(func() { PatternRecallProvider = saved })
|
||||
|
||||
res, _ := p.Recall("pattern 注入测试", "test-ns", 10, 0.0)
|
||||
cnt := 0
|
||||
for _, r := range res {
|
||||
if r.ID == "m_base1" {
|
||||
cnt++
|
||||
}
|
||||
}
|
||||
if cnt != 1 {
|
||||
t.Fatalf("重复 ID 不应二次追加:m_base1 出现 %d 次", cnt)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user