magic-agent 1.0.49 → 1.0.109

package/internal/requirements/requirements_test.go

@@ -0,0 +1,530 @@
+package requirements
+
+// requirements_test.go - 骨架解析 / 合并去重 / 记忆摄入幂等 / 工作区分组。
+//
+// 这些是「归纳」里真正容易错的部分（模型输出那一侧不可控，能验的是代码这一侧）：
+//   · 占位符回吐（模型把「（暂无）」当内容）必须在解析与渲染两处都滤掉；
+//   · 需求点 / 结论保最早、来源 / 流水保最新（清单要稳定，证据要新鲜）；
+//   · 记忆摄入按字节偏移续读，跑两遍不能重复入流（否则每轮都多出一批重复来源）；
+//   · 同一功能点在同一轮里被输出两次，必须原地合并而不是生成 xxx-2.md。
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/darren/magic-agent/internal/agent"
+	"github.com/darren/magic-agent/internal/session"
+)
+
+// testEnv 把需求根目录与会话目录都指向临时目录。
+func testEnv(t *testing.T) string {
+	t.Helper()
+	root := t.TempDir()
+	t.Setenv(EnvDir, filepath.Join(root, "requirements"))
+	t.Setenv(session.EnvDir, filepath.Join(root, "sessions"))
+	return root
+}
+
+func TestParseDocPlaceholders(t *testing.T) {
+	text := `# 登录
+## 最终版
+（待生成）
+
+## 需求描述
+支持手机号登录
+
+## 需求点
+1. 手机号 + 验证码即可登录
+2. （暂无）
+
+## 已定结论
+- （暂无）
+
+## 来源对话
+- [10-22 10:00] #3 想要手机号登录
+
+## 更新记录
+- （暂无）
+`
+	d := ParseDoc(text)
+	if d.Final != "" {
+		t.Errorf("（待生成）应视为空，实际 %q", d.Final)
+	}
+	if len(d.Points) != 1 || d.Points[0] != "手机号 + 验证码即可登录" {
+		t.Errorf("需求点应只留 1 条，实际 %v", d.Points)
+	}
+	if len(d.Conclusions) != 0 {
+		t.Errorf("占位符结论应被丢弃，实际 %v", d.Conclusions)
+	}
+	if len(d.Sources) != 1 {
+		t.Errorf("来源应保留 1 条，实际 %v", d.Sources)
+	}
+}
+
+func TestRenderDocNeverWritesPlaceholder(t *testing.T) {
+	out := RenderDoc("登录", Doc{Points: []string{"（暂无）", "要点"}, Conclusions: []string{"待定"}})
+	if strings.Contains(out, "- （暂无）") || strings.Contains(out, "1. （暂无）") {
+		t.Errorf("渲染出口仍在写占位符:\n%s", out)
+	}
+	if !strings.Contains(out, "（待生成）") {
+		t.Errorf("最终版为空时应写占位，避免半截文件:\n%s", out)
+	}
+	// 反向：再解析回来要还是那一条要点（骨架自洽）。
+	if d := ParseDoc(out); len(d.Points) != 1 || d.Points[0] != "要点" {
+		t.Errorf("渲染后再解析不一致: %+v", d)
+	}
+}
+
+func TestMergeUniqueKeepsHeadAndTail(t *testing.T) {
+	head := mergeUnique([]string{"a", "b"}, []string{"c", "a"}, 2, true, nil)
+	if strings.Join(head, ",") != "a,b" {
+		t.Errorf("保留最早 + 上限 2，应得 a,b，实际 %v", head)
+	}
+	tail := mergeUnique([]string{"x1", "x2"}, []string{"x3"}, 2, false, nil)
+	if strings.Join(tail, ",") != "x2,x3" {
+		t.Errorf("保留最新 + 上限 2，应得 x2,x3，实际 %v", tail)
+	}
+}
+
+func TestSourceKeyIgnoresTimestampAndNo(t *testing.T) {
+	a := sourceKey("[10-22 10:00] #3 想要手机号登录")
+	b := sourceKey("[10-23 09:00] #11 想要手机号登录")
+	if a != b || a == "" {
+		t.Errorf("同一句原话应判重（实际 %q vs %q）", a, b)
+	}
+}
+
+func TestSlugify(t *testing.T) {
+	if got := SlugifyFeature("登录 / 注册"); got != "登录-注册" {
+		t.Errorf("功能点名 slug 不对: %q", got)
+	}
+	if got := SlugifyModule("需求管理模块"); got != "需求管理模块" {
+		t.Errorf("模块名应限 6 字: %q", got)
+	}
+	if got := SlugifyModule("a/b:c"); got != "abc" {
+		t.Errorf("模块名应去非法字符: %q", got)
+	}
+}
+
+// writeSessionLog 造一条会话日志 + 登记记录（模拟 core 跑过一轮）。
+func writeSessionLog(t *testing.T, dir, sid, cwd string, texts ...string) {
+	t.Helper()
+	if err := os.MkdirAll(dir, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	var b strings.Builder
+	for i, s := range texts {
+		ev, _ := json.Marshal(map[string]any{
+			"seq": i + 1, "kind": "user", "text": s,
+			"at": "2026-10-22T10:00:00Z", "session_id": sid,
+		})
+		b.Write(append(ev, '\n'))
+	}
+	if err := os.WriteFile(filepath.Join(dir, sid+".jsonl"), []byte(b.String()), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	// 引擎侧事件（非 user）不该进记忆。
+	extra, _ := json.Marshal(map[string]any{"seq": 99, "kind": "text", "text": "助手的话"})
+	f, err := os.OpenFile(filepath.Join(dir, sid+".jsonl"), os.O_APPEND|os.O_WRONLY, 0o600)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, _ = f.Write(append(extra, '\n'))
+	_ = f.Close()
+
+	h, err := session.Begin(session.BeginOptions{SessionID: sid, Workspace: cwd, PromptHead: texts[0]})
+	if err != nil {
+		t.Fatal(err)
+	}
+	h.Finish(sid, session.StateDone)
+}
+
+func TestIngestIsIdempotent(t *testing.T) {
+	root := testEnv(t)
+	cwd := filepath.Join(root, "proj")
+	if err := os.MkdirAll(cwd, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	writeSessionLog(t, session.Dir(), "s-1", cwd, "第一句", "第二句")
+
+	id := DirID(cwd)
+	st := readState(id)
+	n, err := ingest(id, cwd, &st)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if n != 2 {
+		t.Fatalf("首次应摄入 2 条，实际 %d", n)
+	}
+	if got := readMemory(id); len(got) != 2 {
+		t.Fatalf("记忆流应有 2 条，实际 %d", len(got))
+	}
+	// 第二遍：偏移已到文件尾 → 不该重复入流。
+	n2, err := ingest(id, cwd, &st)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if n2 != 0 {
+		t.Errorf("重复摄入应得 0，实际 %d", n2)
+	}
+	if got := readMemory(id); len(got) != 2 {
+		t.Errorf("记忆流不该变长，实际 %d", len(got))
+	}
+	// 追加一句 → 只补那一条，编号接着走。
+	ev, _ := json.Marshal(map[string]any{"seq": 100, "kind": "user", "text": "第三句", "at": "2026-10-22T11:00:00Z"})
+	f, _ := os.OpenFile(filepath.Join(session.Dir(), "s-1.jsonl"), os.O_APPEND|os.O_WRONLY, 0o600)
+	_, _ = f.Write(append(ev, '\n'))
+	_ = f.Close()
+	if n3, _ := ingest(id, cwd, &st); n3 != 1 {
+		t.Errorf("追加一句应摄入 1，实际 %d", n3)
+	}
+	mem := readMemory(id)
+	if len(mem) != 3 || mem[2].Text != "第三句" || mem[2].N != 3 {
+		t.Errorf("记忆流编号应单调追加，实际 %+v", mem)
+	}
+}
+
+func TestSessionDirForPrefersWorkspace(t *testing.T) {
+	root := testEnv(t)
+	proj := filepath.Join(root, "proj2")
+	if err := os.MkdirAll(proj, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	// 显式 -w 优先于 core 自己的 cwd。
+	if got := sessionDirFor(session.Record{Workspace: proj, Cwd: "/tmp/somewhere"}); got != proj {
+		t.Errorf("Workspace 应优先，实际 %q", got)
+	}
+	// 没有 -w → 用 Cwd（这条会话实际跑在哪个目录）。
+	if got := sessionDirFor(session.Record{Cwd: proj}); got != proj {
+		t.Errorf("无 Workspace 时应回落到 Cwd，实际 %q", got)
+	}
+	// 两者都没有 → 空（宁可漏掉，也不塞进错的目录）。
+	if got := sessionDirFor(session.Record{}); got != "" {
+		t.Errorf("都没有时应为空，实际 %q", got)
+	}
+}
+
+// TestWriteFeatureItemMergesInPlace 同一功能点被输出两次 → 一篇文档、内容合并。
+func TestWriteFeatureItemMergesInPlace(t *testing.T) {
+	root := testEnv(t)
+	id := DirID(filepath.Join(root, "proj3"))
+	merger := newDocMerger(id)
+	// sourcesOf 由代码按记忆编号回查原文（真实链路里由 Consolidate 提供）。
+	quotes := map[int]string{
+		1: "[10-22 10:00] #1 想要手机号登录",
+		2: "[10-22 11:00] #2 不要密码",
+	}
+	ctx := &writeCtx{merger: merger, kind: "归纳", sourcesOf: func(f featureOut) []string {
+		out := []string{}
+		for _, n := range f.Sources {
+			if q, ok := quotes[n]; ok {
+				out = append(out, q)
+			}
+		}
+		return out
+	}}
+
+	a := writeFeatureItem(id, featureOut{
+		Module: "登录", Name: "手机号登录", Desc: "用户用手机号登录",
+		Points:  []string{"手机号 + 验证码即可登录", "（暂无）"},
+		Sources: []int{1},
+	}, ctx)
+	if !a.ok || !a.created || a.points != 1 {
+		t.Fatalf("首次写入应新建 1 篇 + 1 条要点，实际 %+v", a)
+	}
+	// 第二次：同名（模型把名字写长了，会被截断到同一前缀）→ 必须原地合并。
+	b := writeFeatureItem(id, featureOut{
+		Module: "账户", Name: "手机号登录",
+		Points:      []string{"手机号 + 验证码即可登录", "支持微信一键登录"},
+		Conclusions: []string{"不做密码登录"},
+		Sources:     []int{2},
+	}, ctx)
+	if !b.ok || b.created {
+		t.Fatalf("同名应原地合并而不是新建，实际 %+v", b)
+	}
+	if b.points != 1 || b.conclusions != 1 {
+		t.Errorf("应新增 1 条要点 / 1 条结论，实际 %+v", b)
+	}
+	files := listFeatureFiles(id)
+	if len(files) != 1 {
+		t.Fatalf("应只有 1 篇文档，实际 %d: %+v", len(files), files)
+	}
+	if files[0].Module != "登录" {
+		t.Errorf("已有文档不搬家（模块应保持「登录」），实际 %q", files[0].Module)
+	}
+	d := ParseDoc(readFile(t, files[0].File))
+	if len(d.Points) != 2 || len(d.Conclusions) != 1 || len(d.Sources) != 2 {
+		t.Errorf("合并结果不对: %+v", d)
+	}
+	if !strings.Contains(d.Final, "用户用手机号登录") {
+		t.Errorf("最终版应由描述派生: %q", d.Final)
+	}
+	if !strings.Contains(strings.Join(d.Log, "\n"), "归纳：新增需求点 1 条") {
+		t.Errorf("更新记录应记本轮增量: %v", d.Log)
+	}
+}
+
+func readFile(t *testing.T, p string) string {
+	t.Helper()
+	b, err := os.ReadFile(p)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return string(b)
+}
+
+func TestParseFeaturesTolerant(t *testing.T) {
+	cases := []string{
+		`{"features":[{"module":"登录","name":"手机号","desc":"","points":["a"],"conclusions":[],"sources":[1]}]}`,
+		"```json\n{\"features\":[{\"module\":\"登录\",\"name\":\"手机号\",\"sources\":[\"#3\"]}]}\n```",
+		`{"features":[{"module":"登录","name":"手机号","sources":[1]}]}`,
+	}
+	for i, c := range cases {
+		f, err := parseFeatures(c)
+		if err != nil || len(f) != 1 {
+			t.Fatalf("case %d 解析失败: %v", i, err)
+		}
+	}
+	if _, err := parseFeatures("完全不是 JSON"); err == nil {
+		t.Error("不可解析时应报错（让上轮把原因记进 last_error）")
+	}
+}
+
+func TestWorkspacesGroupsAndSorts(t *testing.T) {
+	root := testEnv(t)
+	proj := filepath.Join(root, "proj4")
+	if err := os.MkdirAll(proj, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	writeSessionLog(t, session.Dir(), "s-4", proj, "给登录加个验证码")
+
+	list, err := Workspaces()
+	if err != nil {
+		t.Fatal(err)
+	}
+	id := DirID(proj)
+	var hit *Workspace
+	for i := range list {
+		if list[i].ID == id {
+			hit = &list[i]
+		}
+	}
+	if hit == nil {
+		t.Fatalf("会话侧反推的目录应出现在清单里: %+v", list)
+	}
+	if hit.Dir != proj {
+		t.Errorf("目录应归一为绝对路径，实际 %q", hit.Dir)
+	}
+	// 还没归纳过：pending 是 0（摄入发生在归纳那一轮），文档数为 0。
+	if hit.FeatureCount != 0 {
+		t.Errorf("还没归纳过不该有文档，实际 %d", hit.FeatureCount)
+	}
+}
+
+// TestConsolidatePipeline 走完整链路：摄入 → prompt → 模型输出 → 合并 → 游标前进。
+// 模型用假调用器（真实归纳的网络/CLI 由真机验收覆盖），验的是代码这一侧。
+func TestConsolidatePipeline(t *testing.T) {
+	root := testEnv(t)
+	proj := filepath.Join(root, "proj5")
+	if err := os.MkdirAll(proj, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	writeSessionLog(t, session.Dir(), "s-5", proj, "想要手机号登录", "不要密码登录")
+	// 空目录首次整理也要落初始化标记：不然后面每次点「整理」都会重扫一遍目录。
+	if list, _ := Workspaces(); len(list) > 0 {
+		for _, w := range list {
+			if w.ID == DirID(proj) && w.Initialized {
+				t.Error("还没整理过时 initialized 应为 false")
+			}
+		}
+	}
+
+	old := newCaller
+	defer func() { newCaller = old }()
+	calls := 0
+	newCaller = func(ctx context.Context, engineName, model string, timeout time.Duration) (llmCall, error) {
+		return func(prompt string, schema *agent.JSONSchema) (string, error) {
+			calls++
+			// 首轮：断言关键输入都进了 prompt（记忆编号 / 原文 / 工作区名）。
+			// 之后（--force 且没有新记忆）memory 段本来就是空的，不该再要求有编号。
+			if calls == 1 {
+				for _, want := range []string{"#1", "想要手机号登录", "工作区：proj5"} {
+					if !strings.Contains(prompt, want) {
+						t.Errorf("prompt 缺 %q", want)
+					}
+				}
+			}
+			return `{"features":[{"module":"登录","name":"手机号登录","desc":"用户用手机号登录",
+				"points":["手机号 + 验证码即可登录"],"conclusions":["不做密码登录"],"sources":[1,2]}]}`, nil
+		}, nil
+	}
+
+	res, err := Consolidate(context.Background(), proj, Options{})
+	if err != nil {
+		t.Fatalf("归纳失败: %v", err)
+	}
+	if !res.OK || res.Created != 1 || res.Consumed != 2 || res.Calls != 1 {
+		t.Fatalf("结果不对: %+v", res)
+	}
+	if !res.Bootstrap {
+		t.Errorf("空目录首次整理应标记 bootstrap（目录基线为空，回落会话增量），实际 %+v", res)
+	}
+	if st := readState(res.Workspace); st.BootstrapAt == 0 {
+		t.Error("空目录首次整理也应落 bootstrap_at")
+	}
+	if res.Points != 1 || res.Conclusions != 1 {
+		t.Errorf("应记 1 要点 / 1 结论: %+v", res)
+	}
+	files := listFeatureFiles(res.Workspace)
+	if len(files) != 1 || files[0].Module != "登录" {
+		t.Fatalf("应落一篇 features/登录/手机号登录.md，实际 %+v", files)
+	}
+	d := ParseDoc(readFile(t, files[0].File))
+	if len(d.Sources) != 2 {
+		t.Errorf("来源应按 #编号回查原文得到 2 条，实际 %v", d.Sources)
+	}
+
+	// 再跑一轮：没有新记忆 → noop，不再调模型。
+	res2, err := Consolidate(context.Background(), proj, Options{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !res2.Noop || calls != 1 {
+		t.Errorf("没有新记忆时应 noop 且不调模型，实际 %+v calls=%d", res2, calls)
+	}
+
+	// 强制跑：允许无新记忆也调一次（手动「立即整理」），游标不动。
+	res3, err := Consolidate(context.Background(), proj, Options{Force: true})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if res3.Noop || calls != 2 {
+		t.Errorf("--force 应真跑一轮，实际 %+v calls=%d", res3, calls)
+	}
+	if st := readState(res3.Workspace); st.Consumed != 2 {
+		t.Errorf("没有消费新记忆时游标不该动，实际 %d", st.Consumed)
+	}
+}
+
+// TestConsolidateBootstrapsOnceThenIncremental 首次「整理」按目录反推，之后只处理新会话。
+//
+// 这是 2026-10-22 用户口径的代码化：
+//
+//	· state.BootstrapAt == 0 → 扫目录、让带工具的 agent 产出基线，旧会话记为已消费；
+//	· 之后 → 只把上次游标之后的新 user 事件喂给归纳，不重放历史。
+//
+// 显式默认引擎不能读目录时必须明说，而不是偷偷换一个引擎。
+func TestBootstrapRejectsNonWorkspaceDefaultEngine(t *testing.T) {
+	_, err := pickBootstrapEngine("llm")
+	if err == nil || !strings.Contains(err.Error(), "不能读目录") {
+		t.Fatalf("默认引擎 llm 应被拒绝并说明原因，实际 %v", err)
+	}
+}
+
+func TestConsolidateBootstrapsOnceThenIncremental(t *testing.T) {
+	root := testEnv(t)
+	proj := filepath.Join(root, "proj-bootstrap")
+	if err := os.MkdirAll(proj, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(proj, "README.md"), []byte("# 图书管理\n用户可以借书、还书。\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	writeSessionLog(t, session.Dir(), "s-boot", proj, "旧会话：想借书", "旧会话：想还书")
+
+	oldPick, oldRun := bootstrapEnginePicker, runBootstrapAgent
+	defer func() { bootstrapEnginePicker, runBootstrapAgent = oldPick, oldRun }()
+	bootstrapEnginePicker = func(string) (string, error) { return "claude", nil }
+	var bootPrompt, bootDir string
+	runBootstrapAgent = func(ctx context.Context, engineName, model, dir, prompt string, timeout time.Duration) (string, error) {
+		bootPrompt, bootDir = prompt, dir
+		return `{"features":[{"module":"借阅","name":"借书还书","desc":"用户借书和还书",
+			"points":["扫码借书","到期提醒"],"conclusions":[]}]}`, nil
+	}
+
+	// 初始化这一轮绝不能落到纯文本归纳调用上（那会凭空编需求）。
+	oldCaller := newCaller
+	defer func() { newCaller = oldCaller }()
+	newCaller = func(ctx context.Context, engineName, model string, timeout time.Duration) (llmCall, error) {
+		t.Fatal("首次初始化不应调用文本归纳器")
+		return nil, nil
+	}
+
+	res, err := Consolidate(context.Background(), proj, Options{})
+	if err != nil {
+		t.Fatalf("首次初始化失败: %v", err)
+	}
+	if !res.OK || !res.Bootstrap || res.BootstrapEngine != "claude" {
+		t.Fatalf("首次应走目录初始化，实际 %+v", res)
+	}
+	if res.Created != 1 || res.Points != 2 {
+		t.Errorf("应新建 1 篇 / 2 条需求点，实际 %+v", res)
+	}
+	if bootDir != proj {
+		t.Errorf("初始化必须在工作区目录里读代码，实际 %q", bootDir)
+	}
+	for _, want := range []string{"图书管理", "用户可以借书、还书", "反推"} {
+		if !strings.Contains(bootPrompt, want) {
+			t.Errorf("初始化 prompt 缺 %q", want)
+		}
+	}
+	files := listFeatureFiles(res.Workspace)
+	if len(files) != 1 || files[0].Name != "借书还书" {
+		t.Fatalf("应落一篇目录基线文档，实际 %+v", files)
+	}
+	st := readState(res.Workspace)
+	if st.BootstrapAt == 0 {
+		t.Error("初始化完成后应记 BootstrapAt")
+	}
+	if st.Consumed != 2 {
+		t.Errorf("旧会话应记为已消费（目录基线覆盖），实际 consumed=%d", st.Consumed)
+	}
+	wl, _ := Workspaces()
+	for _, w := range wl {
+		if w.ID == res.Workspace && !w.Initialized {
+			t.Error("清单里的 initialized 应为 true")
+		}
+	}
+
+	// 初始化之后追加一条新会话：只处理这一条，prompt 里不应再出现旧会话原话。
+	ev, _ := json.Marshal(map[string]any{
+		"seq": 100, "kind": "user", "text": "新会话：想加预约功能",
+		"at": "2026-10-22T12:00:00Z", "session_id": "s-boot",
+	})
+	f, err := os.OpenFile(filepath.Join(session.Dir(), "s-boot.jsonl"), os.O_APPEND|os.O_WRONLY, 0o600)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, _ = f.Write(append(ev, '\n'))
+	_ = f.Close()
+
+	var gotPrompt string
+	newCaller = func(ctx context.Context, engineName, model string, timeout time.Duration) (llmCall, error) {
+		return func(prompt string, schema *agent.JSONSchema) (string, error) {
+			gotPrompt = prompt
+			return `{"features":[{"module":"借阅","name":"借书还书","desc":"用户借书和还书",
+				"points":["支持预约"],"conclusions":[],"sources":[3]}]}`, nil
+		}, nil
+	}
+	res2, err := Consolidate(context.Background(), proj, Options{})
+	if err != nil {
+		t.Fatalf("增量整理失败: %v", err)
+	}
+	if res2.Bootstrap {
+		t.Error("已初始化后不应再次反推目录")
+	}
+	if res2.Consumed != 1 {
+		t.Errorf("只应消费新增的 1 条记忆，实际 %d", res2.Consumed)
+	}
+	if !strings.Contains(gotPrompt, "新会话：想加预约功能") {
+		t.Errorf("增量 prompt 应包含新会话，实际：%s", gotPrompt)
+	}
+	if strings.Contains(gotPrompt, "旧会话：想还书") {
+		t.Errorf("增量 prompt 不应重放已初始化前的旧会话，实际：%s", gotPrompt)
+	}
+}