magic-agent 2.4.2 → 2.6.0

package/internal/requirements/modules_test.go

@@ -0,0 +1,373 @@
+package requirements
+
+// modules_test.go - 模块去重（合并「表达同一件事」的已有模块）的代码侧验证。
+//
+// 模型那一侧不可控，能验的是代码这一侧：候选判对、方向归一（功能点多的幸存）、
+// 链式归并、同名文档内容合并不丢、幻觉模块名不认、模块级整理绝不改模块结构、
+// 手动 noop（没有新记忆）也认真清理一次。
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/darren/magic-agent/internal/agent"
+	"github.com/darren/magic-agent/internal/session"
+)
+
+// writeFeatureDoc 直接落一篇功能点文档（造模块结构用，不走模型）。
+func writeFeatureDoc(t *testing.T, id, module, name string, points ...string) {
+	t.Helper()
+	dir := filepath.Join(featuresDir(id), module)
+	if err := os.MkdirAll(dir, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	doc := Doc{Desc: name + "的描述", Points: points}
+	if err := os.WriteFile(filepath.Join(dir, name+".md"), []byte(RenderDoc(name, doc)), 0o600); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestSimilarModulePairs(t *testing.T) {
+	got := similarModulePairs([]string{"引擎管理", "引擎调用", "任务执行"})
+	if len(got) != 1 || got[0] != [2]string{"引擎管理", "引擎调用"} {
+		t.Errorf("共享字应判候选，实际 %v", got)
+	}
+	if got := similarModulePairs([]string{"配置", "配置管理"}); len(got) != 1 {
+		t.Errorf("互为子串应判候选，实际 %v", got)
+	}
+	if got := similarModulePairs([]string{"任务执行", "浏览器控制"}); len(got) != 0 {
+		t.Errorf("不相交不该判候选，实际 %v", got)
+	}
+}
+
+func TestModuleDedupeWanted(t *testing.T) {
+	mods := []string{"引擎管理", "引擎调用"}
+	cases := []struct {
+		name string
+		opts Options
+		res  Result
+		want bool
+	}{
+		{"手动空间级", Options{}, Result{}, true},
+		{"手动无新记忆（noop 也清理）", Options{}, Result{}, true},
+		{"模块级整理永不合并", Options{Module: "引擎管理"}, Result{}, false},
+		{"自动路径要本轮建了新文档", Options{Auto: true}, Result{Created: 1}, true},
+		{"自动路径什么都没建", Options{Auto: true}, Result{}, false},
+	}
+	for _, c := range cases {
+		if got := moduleDedupeWanted(c.opts, c.res, mods); got != c.want {
+			t.Errorf("%s: 得 %v 想 %v", c.name, got, c.want)
+		}
+	}
+	if moduleDedupeWanted(Options{}, Result{}, []string{"登录"}) {
+		t.Error("单模块不该触发")
+	}
+	if moduleDedupeWanted(Options{}, Result{}, []string{"任务执行", "浏览器控制"}) {
+		t.Error("无确定性候选不该触发（不为干净清单烧调用）")
+	}
+}
+
+// TestDedupeModulesMergesSynonym 相似模块 → 并入功能点更多的那个，文档整体搬走 + 记合并记录。
+func TestDedupeModulesMergesSynonym(t *testing.T) {
+	root := testEnv(t)
+	id := DirID(filepath.Join(root, "proj-merge"))
+	writeFeatureDoc(t, id, "引擎调用", "调用编排", "一次提问跑一个引擎")
+	writeFeatureDoc(t, id, "引擎管理", "引擎切换", "切换默认引擎")
+	writeFeatureDoc(t, id, "引擎管理", "引擎探测", "探测本机装了哪些引擎")
+
+	call := func(prompt string, schema *agent.JSONSchema) (string, error) {
+		if !strings.Contains(prompt, "需要合并成一个") {
+			t.Errorf("模块合并 prompt 形态不对: %s", prompt)
+		}
+		return `{"pairs":[{"from":"引擎调用","to":"引擎管理"}]}`, nil
+	}
+	merged := dedupeModules(id, call)
+	if len(merged) != 1 || merged[0] != "引擎调用 → 引擎管理" {
+		t.Fatalf("应合并 引擎调用→引擎管理，实际 %v", merged)
+	}
+	files := listFeatureFiles(id)
+	if len(files) != 3 {
+		t.Fatalf("三篇文档都该在，实际 %+v", files)
+	}
+	for _, f := range files {
+		if f.Module != "引擎管理" {
+			t.Errorf("文档应都在引擎管理下，实际 %q: %s", f.Module, f.Name)
+		}
+	}
+	if _, err := os.Stat(filepath.Join(featuresDir(id), "引擎调用")); !os.IsNotExist(err) {
+		t.Error("搬空后引擎调用目录应撤掉")
+	}
+	d := ParseDoc(readFile(t, filepath.Join(featuresDir(id), "引擎管理", "调用编排.md")))
+	if len(d.Log) != 1 || !strings.Contains(d.Log[0], "模块合并") {
+		t.Errorf("搬走的文档应记一行合并记录，实际 %v", d.Log)
+	}
+}
+
+// TestDedupeModulesMergesSameNameDoc 两个模块下同一个功能点 → 合并成一篇，内容不丢。
+func TestDedupeModulesMergesSameNameDoc(t *testing.T) {
+	root := testEnv(t)
+	id := DirID(filepath.Join(root, "proj-samename"))
+	writeFeatureDoc(t, id, "模型配置", "默认模型", "默认用 claude")
+	writeFeatureDoc(t, id, "配置管理", "默认模型", "默认模型可改")
+
+	call := func(prompt string, schema *agent.JSONSchema) (string, error) {
+		return `{"pairs":[{"from":"模型配置","to":"配置管理"}]}`, nil
+	}
+	merged := dedupeModules(id, call)
+	if len(merged) != 1 || merged[0] != "模型配置 → 配置管理" {
+		t.Fatalf("应合并 模型配置→配置管理，实际 %v", merged)
+	}
+	files := listFeatureFiles(id)
+	if len(files) != 1 || files[0].Module != "配置管理" || files[0].Name != "默认模型" {
+		t.Fatalf("同名文档应合并成一篇，实际 %+v", files)
+	}
+	d := ParseDoc(readFile(t, files[0].File))
+	if len(d.Points) != 2 || d.Points[0] != "默认模型可改" || d.Points[1] != "默认用 claude" {
+		t.Errorf("要点应 目标在前来源在后，实际 %v", d.Points)
+	}
+	if len(d.Log) != 1 || !strings.Contains(d.Log[0], "模块合并") {
+		t.Errorf("合并记录应记在幸存文档里，实际 %v", d.Log)
+	}
+}
+
+// TestDedupeModulesChain 链式 A→B→C 都归到功能点最多的 C。
+func TestDedupeModulesChain(t *testing.T) {
+	root := testEnv(t)
+	id := DirID(filepath.Join(root, "proj-chain"))
+	writeFeatureDoc(t, id, "会话管理", "会话列表", "看到全部会话")
+	writeFeatureDoc(t, id, "对话交互", "消息渲染", "渲染消息")
+	writeFeatureDoc(t, id, "对话管理", "消息变体", "消息有几种样式")
+	writeFeatureDoc(t, id, "对话管理", "消息重发", "60 秒可重发")
+
+	call := func(prompt string, schema *agent.JSONSchema) (string, error) {
+		// 会话管理→对话交互（数量持平听模型的）、对话交互→对话管理（1<2 不翻向）
+		return `{"pairs":[{"from":"会话管理","to":"对话交互"},{"from":"对话交互","to":"对话管理"}]}`, nil
+	}
+	merged := dedupeModules(id, call)
+	if len(merged) != 2 {
+		t.Fatalf("链式应合并 2 个模块，实际 %v", merged)
+	}
+	files := listFeatureFiles(id)
+	if len(files) != 4 {
+		t.Fatalf("四篇文档都该在，实际 %+v", files)
+	}
+	for _, f := range files {
+		if f.Module != "对话管理" {
+			t.Errorf("链式终点应是对话管理，实际 %q: %s", f.Module, f.Name)
+		}
+	}
+}
+
+func TestDedupeModulesKeepsDistinct(t *testing.T) {
+	root := testEnv(t)
+	id := DirID(filepath.Join(root, "proj-distinct"))
+	writeFeatureDoc(t, id, "内容创作", "写文案", "生成文案")
+	writeFeatureDoc(t, id, "团队协作", "分工", "拆子任务")
+
+	call := func(prompt string, schema *agent.JSONSchema) (string, error) {
+		return `{"pairs":[]}`, nil
+	}
+	if merged := dedupeModules(id, call); len(merged) != 0 {
+		t.Errorf("模型说没有同义时不该合并，实际 %v", merged)
+	}
+	if mods := listModules(id); len(mods) != 2 {
+		t.Errorf("两个模块都该留着，实际 %v", mods)
+	}
+}
+
+// TestDedupeModulesIgnoresInvalidPairs 模型编一个不存在的模块名 → 一律不认。
+func TestDedupeModulesIgnoresInvalidPairs(t *testing.T) {
+	root := testEnv(t)
+	id := DirID(filepath.Join(root, "proj-invalid"))
+	writeFeatureDoc(t, id, "内容创作", "写文案", "生成文案")
+	writeFeatureDoc(t, id, "团队协作", "分工", "拆子任务")
+
+	call := func(prompt string, schema *agent.JSONSchema) (string, error) {
+		return `{"pairs":[{"from":"不存在的模块","to":"内容创作"},{"from":"团队协作","to":"幻觉模块"}]}`, nil
+	}
+	if merged := dedupeModules(id, call); len(merged) != 0 {
+		t.Errorf("幻觉模块名不该被合并，实际 %v", merged)
+	}
+	if mods := listModules(id); len(mods) != 2 {
+		t.Errorf("两个模块都该留着，实际 %v", mods)
+	}
+}
+
+// TestConsolidateDedupesModulesAcrossRounds 跨轮堆积的相似模块，被收尾的模块去重合并掉。
+//
+// 关键在假调用器分流三种 prompt：归纳（返 features）、新模块二审（放水返空）、
+// 模块合并（返同义 pair）—— 二审放水后近义模块照常建出来，交给去重收尾。
+func TestConsolidateDedupesModulesAcrossRounds(t *testing.T) {
+	root := testEnv(t)
+	proj := filepath.Join(root, "proj-dedupe")
+	if err := os.MkdirAll(proj, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	writeSessionLog(t, session.Dir(), "s-dedupe", proj, "引擎切换加上", "调用时带上超时")
+	id := DirID(proj)
+	// 已初始化 + 游标 0：跳过目录初始化，直接走会话增量
+	if err := writeState(id, state{BootstrapAt: time.Now().UnixMilli(), Sessions: map[string]memCursor{}}); err != nil {
+		t.Fatal(err)
+	}
+
+	old := newCaller
+	defer func() { newCaller = old }()
+	round := 0
+	newCaller = func(ctx context.Context, engineName, model string, timeout time.Duration) (llmCall, error) {
+		return func(prompt string, schema *agent.JSONSchema) (string, error) {
+			switch {
+			case strings.Contains(prompt, "== 归纳规则 =="):
+				round++
+				if round == 1 {
+					return `{"features":[{"module":"引擎管理","name":"引擎切换","desc":"用户切换默认引擎","points":["可切换默认引擎"],"sources":[1]}]}`, nil
+				}
+				return `{"features":[{"module":"引擎调用","name":"调用超时","desc":"用户设置调用超时","points":["可设置调用超时"],"sources":[3]}]}`, nil
+			case strings.Contains(prompt, "本轮新增模块"):
+				return `{"pairs":[]}`, nil // 二审放水：模拟模型没判出来
+			default:
+				return `{"pairs":[{"from":"引擎调用","to":"引擎管理"}]}`, nil
+			}
+		}, nil
+	}
+
+	// 第一轮：只建出「引擎管理」一个模块，不够去重门槛。
+	res, err := Consolidate(context.Background(), proj, Options{})
+	if err != nil {
+		t.Fatalf("第一轮归纳失败: %v", err)
+	}
+	if res.Created != 1 || res.Merged != 0 {
+		t.Fatalf("第一轮只该新建 1 篇、不合并，实际 %+v", res)
+	}
+	if mods := listModules(id); len(mods) != 1 || mods[0] != "引擎管理" {
+		t.Fatalf("第一轮后应只有引擎管理，实际 %v", mods)
+	}
+
+	// 追加一条新记忆 → 第二轮建出「引擎调用」（二审放水），收尾去重把它并进引擎管理。
+	ev, err := os.OpenFile(filepath.Join(session.Dir(), "s-dedupe.jsonl"), os.O_APPEND|os.O_WRONLY, 0o600)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = ev.Close() }()
+	line := `{"seq":100,"kind":"user","text":"调用默认引擎带上超时","at":"2026-10-25T10:00:00Z","session_id":"s-dedupe"}` + "\n"
+	if _, err := ev.WriteString(line); err != nil {
+		t.Fatal(err)
+	}
+
+	res2, err := Consolidate(context.Background(), proj, Options{})
+	if err != nil {
+		t.Fatalf("第二轮归纳失败: %v", err)
+	}
+	if res2.Created != 1 || res2.Merged != 1 {
+		t.Fatalf("第二轮应新建 1 篇 + 合并 1 个模块，实际 %+v", res2)
+	}
+	if len(res2.MergedModules) != 1 || res2.MergedModules[0] != "引擎调用 → 引擎管理" {
+		t.Errorf("合并清单不对: %v", res2.MergedModules)
+	}
+	files := listFeatureFiles(id)
+	if len(files) != 2 {
+		t.Fatalf("两篇文档都该在，实际 %+v", files)
+	}
+	for _, f := range files {
+		if f.Module != "引擎管理" {
+			t.Errorf("文档应都在引擎管理下，实际 %q: %s", f.Module, f.Name)
+		}
+	}
+	if _, err := os.Stat(filepath.Join(featuresDir(id), "引擎调用")); !os.IsNotExist(err) {
+		t.Error("搬空后引擎调用目录应撤掉")
+	}
+}
+
+// TestConsolidateDedupesOnIdle 没有新记忆的手动「整理」也认真清理一次（不只会说 noop）。
+func TestConsolidateDedupesOnIdle(t *testing.T) {
+	root := testEnv(t)
+	proj := filepath.Join(root, "proj-idle")
+	if err := os.MkdirAll(proj, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	writeSessionLog(t, session.Dir(), "s-idle", proj, "一句话")
+	id := DirID(proj)
+	writeFeatureDoc(t, id, "引擎调用", "调用编排", "一次提问跑一个引擎")
+	writeFeatureDoc(t, id, "引擎管理", "引擎切换", "切换默认引擎")
+	writeFeatureDoc(t, id, "引擎管理", "引擎探测", "探测本机装了哪些引擎")
+	// 已初始化 + 全部已消费：手动整理走 noop 分支
+	if err := writeState(id, state{BootstrapAt: time.Now().UnixMilli(), Consumed: 1, Sessions: map[string]memCursor{}}); err != nil {
+		t.Fatal(err)
+	}
+
+	old := newCaller
+	defer func() { newCaller = old }()
+	asked := 0
+	newCaller = func(ctx context.Context, engineName, model string, timeout time.Duration) (llmCall, error) {
+		return func(prompt string, schema *agent.JSONSchema) (string, error) {
+			asked++
+			if strings.Contains(prompt, "== 归纳规则 ==") {
+				t.Errorf("没有新记忆不该跑归纳 prompt")
+			}
+			return `{"pairs":[{"from":"引擎调用","to":"引擎管理"}]}`, nil
+		}, nil
+	}
+
+	res, err := Consolidate(context.Background(), proj, Options{})
+	if err != nil {
+		t.Fatalf("整理失败: %v", err)
+	}
+	if res.Noop {
+		t.Error("合并了模块就不算 noop（用户该看到反馈）")
+	}
+	if !res.OK || res.Merged != 1 || asked != 1 {
+		t.Fatalf("应只问一次模型并合并 1 个模块，实际 %+v asked=%d", res, asked)
+	}
+	files := listFeatureFiles(id)
+	if len(files) != 3 {
+		t.Fatalf("三篇文档都该在，实际 %+v", files)
+	}
+	for _, f := range files {
+		if f.Module != "引擎管理" {
+			t.Errorf("文档应都在引擎管理下，实际 %q: %s", f.Module, f.Name)
+		}
+	}
+}
+
+// TestConsolidateModuleScopeNeverMergesModules 模块级整理只动这个模块，绝不改模块结构。
+func TestConsolidateModuleScopeNeverMergesModules(t *testing.T) {
+	root := testEnv(t)
+	proj := filepath.Join(root, "proj-scope-nomerge")
+	if err := os.MkdirAll(proj, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	writeSessionLog(t, session.Dir(), "s-scope2", proj, "引擎切换要能按名字排序")
+	id := DirID(proj)
+	writeFeatureDoc(t, id, "引擎调用", "调用编排", "一次提问跑一个引擎")
+	writeFeatureDoc(t, id, "引擎管理", "引擎切换", "切换默认引擎")
+	writeFeatureDoc(t, id, "引擎管理", "引擎探测", "探测本机装了哪些引擎")
+	if err := writeState(id, state{BootstrapAt: time.Now().UnixMilli(), Sessions: map[string]memCursor{}}); err != nil {
+		t.Fatal(err)
+	}
+
+	old := newCaller
+	defer func() { newCaller = old }()
+	newCaller = func(ctx context.Context, engineName, model string, timeout time.Duration) (llmCall, error) {
+		return func(prompt string, schema *agent.JSONSchema) (string, error) {
+			if strings.Contains(prompt, "本轮新增模块") || strings.Contains(prompt, "需要合并成一个") {
+				t.Errorf("模块级整理不该问模块二审/合并: %s", prompt)
+			}
+			return `{"features":[{"module":"引擎管理","name":"引擎切换","points":["可按名称排序"],"sources":[1]}]}`, nil
+		}, nil
+	}
+
+	res, err := Consolidate(context.Background(), proj, Options{Module: "引擎管理"})
+	if err != nil {
+		t.Fatalf("模块级整理失败: %v", err)
+	}
+	if res.Merged != 0 {
+		t.Errorf("模块级整理不该合并模块，实际 %+v", res)
+	}
+	mods := listModules(id)
+	if !contains(mods, "引擎调用") || !contains(mods, "引擎管理") {
+		t.Errorf("两个模块都该原地留着，实际 %v", mods)
+	}
+}

package/internal/requirements/relations.go

@@ -0,0 +1,155 @@
+package requirements
+
+import (
+	"bufio"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strconv"
+)
+
+// Relation 一条「会话 ↔ 需求功能点」的关联记录。
+//
+// 文档的「来源对话」段只存展示文本（30 条截断、无 session id），关系会静默丢失；
+// 这里按 (session, module, feature, n) 显式落一行，供图谱聚合。
+// STitle 是写入当时的会话标题快照 —— 会话登记表会被清理，老会话查不到标题，
+// 图谱不能依赖事后回查。
+type Relation struct {
+	Ts      int64  `json:"ts"`
+	Session string `json:"session"`
+	STitle  string `json:"stitle,omitempty"`
+	Module  string `json:"module"`
+	Feature string `json:"feature"`
+	N       int    `json:"n,omitempty"`
+}
+
+// relationsFile 会话↔需求关系流（追加型，与 memory.jsonl 同风格）。
+func relationsFile(id string) string { return filepath.Join(wsDir(id), "relations.jsonl") }
+
+// appendRelations 追加关系行。写入期只 append 不读不比 —— 去重统一由
+// compactRelations 在归纳收尾做，别把去重逻辑散到各写入点。
+func appendRelations(id string, rels []Relation) error {
+	if len(rels) == 0 {
+		return nil
+	}
+	if err := os.MkdirAll(wsDir(id), 0o700); err != nil {
+		return err
+	}
+	f, err := os.OpenFile(relationsFile(id), os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o600)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	enc := json.NewEncoder(f)
+	for _, r := range rels {
+		if r.Session == "" || r.Feature == "" {
+			continue // 没有会话归属的（基线初始化）不记关系
+		}
+		if err := enc.Encode(r); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// readRelations 读全量关系行（单行坏了跳过，尽力而为）。
+func readRelations(id string) []Relation {
+	f, err := os.Open(relationsFile(id))
+	if err != nil {
+		return nil
+	}
+	defer f.Close()
+	var out []Relation
+	sc := bufio.NewScanner(f)
+	sc.Buffer(make([]byte, 0, 64*1024), 1024*1024)
+	for sc.Scan() {
+		line := []byte(sc.Text())
+		if len(line) == 0 {
+			continue
+		}
+		var r Relation
+		if json.Unmarshal(line, &r) == nil && r.Session != "" && r.Feature != "" {
+			out = append(out, r)
+		}
+	}
+	return out
+}
+
+// relationKey 判重键：同一会话对同一功能点的同一条来源只记一次。
+func relationKey(r Relation) string {
+	return r.Session + "\x00" + r.Module + "\x00" + r.Feature + "\x00" + strconv.Itoa(r.N)
+}
+
+// compactRelations 全量去重（保最后一次出现的字段值），原子重写。
+func compactRelations(id string) error {
+	rels := readRelations(id)
+	if rels == nil {
+		return nil // 文件不存在：无事可做
+	}
+	seen := make(map[string]Relation, len(rels))
+	order := make([]string, 0, len(rels))
+	for _, r := range rels {
+		k := relationKey(r)
+		if _, ok := seen[k]; ok {
+			seen[k] = r // 后写覆盖前写（Ts 等取最新）
+			continue
+		}
+		seen[k] = r
+		order = append(order, k)
+	}
+	tmp := relationsFile(id) + ".tmp"
+	f, err := os.OpenFile(tmp, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0o600)
+	if err != nil {
+		return err
+	}
+	enc := json.NewEncoder(f)
+	for _, k := range order {
+		if err := enc.Encode(seen[k]); err != nil {
+			f.Close()
+			os.Remove(tmp)
+			return err
+		}
+	}
+	if err := f.Close(); err != nil {
+		os.Remove(tmp)
+		return err
+	}
+	return os.Rename(tmp, relationsFile(id))
+}
+
+// rewriteRelationsModule 模块合并后把 from 的归属改写成 to ——
+// 搬目录后 from 目录被删，不改写图谱里会出现悬空模块。
+func rewriteRelationsModule(id, from, to string) error {
+	rels := readRelations(id)
+	if rels == nil {
+		return nil
+	}
+	changed := false
+	for i, r := range rels {
+		if r.Module == from {
+			rels[i].Module = to
+			changed = true
+		}
+	}
+	if !changed {
+		return nil
+	}
+	tmp := relationsFile(id) + ".tmp"
+	f, err := os.OpenFile(tmp, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0o600)
+	if err != nil {
+		return err
+	}
+	enc := json.NewEncoder(f)
+	for _, r := range rels {
+		if err := enc.Encode(r); err != nil {
+			f.Close()
+			os.Remove(tmp)
+			return err
+		}
+	}
+	if err := f.Close(); err != nil {
+		os.Remove(tmp)
+		return err
+	}
+	return os.Rename(tmp, relationsFile(id))
+}