magic-agent 2.4.3 → 2.6.3

package/internal/client/jobs_auto_test.go

@@ -0,0 +1,431 @@
+package client
+
+// jobs_auto_test.go - 「自动」任务模式的判定闸门（2026-10-26）。
+//
+// 钉住的口径（用户定稿）：
+//   · 先规则再走建议引擎：合同一顿快速通道不调模型；同会话 / 文件交集直接判串行；
+//   · 判定失败、超时、没配引擎 → **默认并行**（保护不是闸门，不能把任务卡死）；
+//   · judging 不是调度候选 → 判定期间绝不能被抢跑；
+//   · 重启后不重判：judging 残留按并行放行（用户明确「不需要 60 秒后重新判定」）；
+//   · 同空间连发两条：第二条必须看得见第一条（queued 也算候选），否则两条同时改同一个文件。
+
+import (
+	"encoding/json"
+	"io"
+	"log"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/darren/magic-agent/internal/judge"
+	"github.com/darren/magic-agent/internal/session"
+)
+
+func autoTestQueue(t *testing.T, core string) *jobQueue {
+	t.Helper()
+	dir := t.TempDir()
+	t.Setenv("MAGIC_CLIENT_JOBS_DIR", filepath.Join(dir, "jobs"))
+	t.Setenv(session.EnvDir, filepath.Join(dir, "sessions"))
+	svc := &Service{
+		opts: Options{MagicAgent: core, Profile: DefaultProfile()},
+		log:  log.New(io.Discard, "", 0),
+		runs: map[string]*askRun{},
+	}
+	q := newJobQueue(svc)
+	t.Cleanup(func() {
+		q.close()
+		time.Sleep(150 * time.Millisecond)
+	})
+	return q
+}
+
+// fakeJudgeCore 只会 --judge-conflict 的假 core（判定用，不跑任务）。
+func fakeJudgeCore(t *testing.T, body string) string {
+	t.Helper()
+	if runtime.GOOS == "windows" {
+		t.Skip("假 core 用 sh 脚本；Windows 上的判定逻辑由纯函数测试覆盖")
+	}
+	dir := t.TempDir()
+	path := filepath.Join(dir, "magic-agent")
+	script := "#!/bin/sh\ncat >/dev/null\necho '" + body + "'\n"
+	if err := os.WriteFile(path, []byte(script), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	return path
+}
+
+// writeRunningSession 直接在登记表里落一条「正在跑」的记录（PID 用本测试进程，探活会通过）。
+func writeRunningSession(t *testing.T, ws, runID, sid, title string) {
+	t.Helper()
+	dir := session.Dir()
+	if err := os.MkdirAll(dir, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	rec := session.Record{
+		RunID: runID, SessionID: sid, PID: os.Getpid(), Engine: "claude",
+		Workspace: ws, PromptHead: title,
+		State: session.StateRunning, StartedAt: time.Now(), UpdatedAt: time.Now(),
+	}
+	b, _ := json.Marshal(rec)
+	if err := os.WriteFile(filepath.Join(dir, runID+".json"), b, 0o600); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func waitJobState(t *testing.T, q *jobQueue, id string, want func(*Job) bool) *Job {
+	t.Helper()
+	deadline := time.Now().Add(3 * time.Second)
+	var last *Job
+	for time.Now().Before(deadline) {
+		if last = q.get(id); last != nil && want(last) {
+			return last
+		}
+		time.Sleep(20 * time.Millisecond)
+	}
+	t.Fatalf("作业 %s 未达到期望状态，最后：%+v（auto=%+v）", id, last, last.GetAuto())
+	return last
+}
+
+// GetAuto 测试辅助：避免 nil 指针。
+func (j *Job) GetAuto() *JobAuto {
+	if j == nil || j.Auto == nil {
+		return &JobAuto{}
+	}
+	return j.Auto
+}
+
+func TestAutoIdleSpaceRunsParallelWithoutModel(t *testing.T) {
+	ws := t.TempDir()
+	q := autoTestQueue(t, "")
+	j, created, err := q.submitAsk(askRequest{Prompt: "改一下底部栏", Mode: "auto", Workspace: ws}, "claude", "pc")
+	if err != nil || !created {
+		t.Fatalf("submitAsk: err=%v created=%v", err, created)
+	}
+	if j.State != JobQueued || j.Serial {
+		t.Fatalf("空间空闲应直接并行（queued + serial=false），实际 state=%s serial=%v", j.State, j.Serial)
+	}
+	if j.GetAuto().By != "rule" {
+		t.Errorf("空闲快速通道应标 by=rule（不调模型），实际 %q", j.GetAuto().By)
+	}
+	if j.Mode != "auto" {
+		t.Errorf("作业应记住 mode=auto，实际 %q", j.Mode)
+	}
+}
+
+func TestAutoSameSessionForcesSerial(t *testing.T) {
+	ws := t.TempDir()
+	q := autoTestQueue(t, "")
+	q.mu.Lock()
+	q.jobs["job-running"] = &Job{
+		ID: "job-running", Workspace: ws, Session: "sess-1", Engine: "claude",
+		Prompt: "上一轮", State: JobRunning, Serial: false,
+	}
+	q.mu.Unlock()
+
+	j, _, err := q.submitAsk(askRequest{Prompt: "追问一句", Mode: "auto", Session: "sess-1", Workspace: ws}, "claude", "pc")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !j.Serial {
+		t.Fatalf("同一会话还有一轮没结束，必须串行，实际 serial=%v", j.Serial)
+	}
+	if j.GetAuto().By != "rule" {
+		t.Errorf("同会话是硬规则，应标 by=rule，实际 %q", j.GetAuto().By)
+	}
+}
+
+func TestAutoUndecidedFallsBackToParallel(t *testing.T) {
+	ws := t.TempDir()
+	// 没有可用 core → 语义判定必然失败 → 按并行放行，且如实标 undecided。
+	q := autoTestQueue(t, "")
+	writeRunningSession(t, ws, "run-busy", "sess-busy", "改底部栏")
+
+	j, _, err := q.submitAsk(askRequest{Prompt: "写个 README", Mode: "auto", Workspace: ws}, "claude", "pc")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if j.State != JobJudging {
+		t.Fatalf("有运行中候选时应先进 judging，实际 %s", j.State)
+	}
+	/* 判定完成后队列会立刻准入选（本测试没有可跑的 core，可能转 running/failed）——
+	   这里只验判定结论本身：不再 pending，且按并行放行。 */
+	got := waitJobState(t, q, j.ID, func(x *Job) bool { return x.GetAuto().By != "pending" && x.State != JobJudging })
+	if got.Serial {
+		t.Fatalf("判定失败必须按并行放行，实际 serial=true（auto=%+v）", got.Auto)
+	}
+	if got.GetAuto().By != "undecided" {
+		t.Errorf("应标 by=undecided，实际 %q", got.GetAuto().By)
+	}
+	if !strings.Contains(got.GetAuto().Reason, "并行") {
+		t.Errorf("理由要说明按并行放行，实际 %q", got.GetAuto().Reason)
+	}
+}
+
+func TestAutoModelConflictQueues(t *testing.T) {
+	ws := t.TempDir()
+	core := fakeJudgeCore(t, `{"conflict":true,"level":"hard","reason":"都要改 index.html","overlaps":["index.html"]}`)
+	q := autoTestQueue(t, core)
+	writeRunningSession(t, ws, "run-busy", "sess-busy", "改底部栏")
+
+	j, _, err := q.submitAsk(askRequest{Prompt: "改底部栏的配色", Mode: "auto", Workspace: ws}, "claude", "pc")
+	if err != nil {
+		t.Fatal(err)
+	}
+	got := waitJobState(t, q, j.ID, func(x *Job) bool { return x.State == JobQueued })
+	if !got.Serial {
+		t.Fatalf("模型判冲突应转串行，实际 serial=false（auto=%+v）", got.Auto)
+	}
+	if got.GetAuto().By != "model" {
+		t.Errorf("应标 by=model，实际 %q", got.GetAuto().By)
+	}
+	if !strings.Contains(got.GetAuto().Reason, "index.html") {
+		t.Errorf("理由应带冲突点，实际 %q", got.GetAuto().Reason)
+	}
+}
+
+func TestAutoModelClearRunsParallel(t *testing.T) {
+	ws := t.TempDir()
+	core := fakeJudgeCore(t, `{"conflict":false,"level":"none","reason":"互不相干：一个改前端一个写文档"}`)
+	q := autoTestQueue(t, core)
+	writeRunningSession(t, ws, "run-busy", "sess-busy", "改底部栏")
+
+	j, _, err := q.submitAsk(askRequest{Prompt: "补一段说明文档", Mode: "auto", Workspace: ws}, "claude", "pc")
+	if err != nil {
+		t.Fatal(err)
+	}
+	got := waitJobState(t, q, j.ID, func(x *Job) bool { return x.GetAuto().By != "pending" && x.State != JobJudging })
+	if got.Serial {
+		t.Fatalf("模型判不冲突应并行，实际 serial=true（auto=%+v）", got.Auto)
+	}
+	if got.GetAuto().By != "model" {
+		t.Errorf("应标 by=model，实际 %q", got.GetAuto().By)
+	}
+}
+
+/*
+连发两条：第一条判并行（空间空闲），第二条必须看得见它。
+
+	不把 queued 算进候选时的现场是：两条都走「空间空闲」快速通道、都不看对方，
+	最后两个进程同时改同一个文件 —— 正是自动模式要防的那件事。
+*/
+func TestAutoSeesQueuedPeer(t *testing.T) {
+	ws := t.TempDir()
+	core := fakeJudgeCore(t, `{"conflict":true,"level":"hard","reason":"都要改同一个页面"}`)
+	q := autoTestQueue(t, core)
+
+	first, _, err := q.submitAsk(askRequest{Prompt: "改底部栏的配色", Mode: "auto", Workspace: ws}, "claude", "pc")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if first.State != JobQueued || first.Serial {
+		t.Fatalf("第一条在空闲空间应直接并行，实际 state=%s serial=%v", first.State, first.Serial)
+	}
+	// 第一条还没开跑（测试不发 dispatch），此时提交第二条。
+	second, _, err := q.submitAsk(askRequest{Prompt: "改底部栏的图标大小", Mode: "auto", Workspace: ws}, "claude", "pc")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if second.State != JobJudging {
+		t.Fatalf("同空间还有排队作业时应进判定，实际 %s", second.State)
+	}
+	got := waitJobState(t, q, second.ID, func(x *Job) bool { return x.GetAuto().By != "pending" })
+	if !got.Serial {
+		t.Fatalf("第二条与排队中的第一条冲突，应串行，实际 serial=false（auto=%+v）", got.Auto)
+	}
+}
+
+func TestAutoJudgingNotDispatchable(t *testing.T) {
+	ws := t.TempDir()
+	q := autoTestQueue(t, "")
+	q.mu.Lock()
+	q.jobs["job-judge"] = &Job{
+		ID: "job-judge", Workspace: ws, Engine: "claude", Prompt: "判定中",
+		State: JobJudging, Serial: false, CreatedAt: time.Now(), UpdatedAt: time.Now(),
+	}
+	q.mu.Unlock()
+
+	q.dispatch()
+	if got := q.get("job-judge"); got.State != JobJudging {
+		t.Fatalf("judging 不能被 dispatch 抢跑，实际 %s", got.State)
+	}
+	if q.runOf("job-judge") != nil {
+		t.Fatal("judging 期间不应有正在跑的轮次")
+	}
+}
+
+func TestAutoJudgingRecoversAsParallelAfterRestart(t *testing.T) {
+	dir := t.TempDir()
+	t.Setenv("MAGIC_CLIENT_JOBS_DIR", dir)
+	t.Setenv(session.EnvDir, filepath.Join(dir, "sessions"))
+	j := Job{
+		ID: "job-judging", RequestID: "req-judging", Workspace: "/tmp/ws", Engine: "claude",
+		Prompt: "判定中被重启", Mode: "auto", State: JobJudging, Serial: false,
+		Auto:      &JobAuto{By: "pending", Reason: "正在判断"},
+		CreatedAt: time.Now(), UpdatedAt: time.Now(), ExpiresAt: time.Now().Add(time.Hour),
+	}
+	b, _ := json.Marshal(j)
+	if err := os.WriteFile(filepath.Join(dir, j.ID+".json"), b, 0o600); err != nil {
+		t.Fatal(err)
+	}
+	svc := &Service{opts: Options{Profile: DefaultProfile()}, log: log.New(io.Discard, "", 0), runs: map[string]*askRun{}}
+	q := newJobQueue(svc)
+	defer q.close()
+
+	got := q.get("job-judging")
+	if got == nil || got.State != JobQueued {
+		t.Fatalf("judging 残留重启后应转 queued，实际 %+v", got)
+	}
+	if got.Serial {
+		t.Error("重启不重判 → 必须按并行放行")
+	}
+	if got.GetAuto().By != "undecided" {
+		t.Errorf("应标 undecided，实际 %q", got.GetAuto().By)
+	}
+}
+
+func TestSpaceKeyNormalizesTeamRunDir(t *testing.T) {
+	ws := filepath.Join(string(filepath.Separator), "tmp", "proj")
+	run := filepath.Join(ws, ".magic", "team", "run-abc", "t1")
+	if got, want := spaceKeyOf(run), spaceKeyOf(ws); got != want {
+		t.Fatalf("团队运行目录应归到父空间：%q != %q", got, want)
+	}
+	// 尾斜杠 / 相对路径写法要归到同一个键（core 的锁键同口径）。
+	if !sameSpace(spaceKeyOf(ws+string(filepath.Separator)), spaceKeyOf(ws)) {
+		t.Error("尾斜杠应归一到同一个空间")
+	}
+}
+
+func TestPromptFileOverlap(t *testing.T) {
+	cands := []judge.Candidate{
+		{Files: []string{"client-ui-mobile/index.html", "docs/a.md"}},
+	}
+	// 完整路径
+	if _, ov := promptFileOverlap("改 client-ui-mobile/index.html 的底部栏", cands); len(ov) == 0 {
+		t.Error("提示词里写出完整路径应判冲突")
+	}
+	// 文件名（带扩展名）
+	if _, ov := promptFileOverlap("把 index.html 的底部栏调窄", cands); len(ov) == 0 {
+		t.Error("提示词里写出文件名应判冲突")
+	}
+	// 不相干
+	if _, ov := promptFileOverlap("写一篇公众号文章", cands); len(ov) != 0 {
+		t.Errorf("不相干的提示词不该判冲突，实际 %v", ov)
+	}
+}
+
+func TestPathsInToolInput(t *testing.T) {
+	cases := map[string]string{
+		`{"file_path":"/a/b.go"}`:              "/a/b.go",
+		`{"path":"src/x.ts"}`:                  "src/x.ts",
+		`{"notebook_path":"n.ipynb"}`:          "n.ipynb",
+		`{"patch":"*** Update File: /a/b.md"}`: "", // 认不出就老实返回空，别瞎猜
+	}
+	for in, want := range cases {
+		got := pathsInToolInput(in)
+		if want == "" {
+			if len(got) != 0 {
+				t.Errorf("输入 %s 不该抽出路径，实际 %v", in, got)
+			}
+			continue
+		}
+		found := false
+		for _, g := range got {
+			if g == want {
+				found = true
+			}
+		}
+		if !found {
+			t.Errorf("输入 %s 应抽出 %q，实际 %v", in, want, got)
+		}
+	}
+}
+
+// autoHTTPCore 既是任务 core（NDJSON + 等 stop）又是判定 core（--judge-conflict 回 JSON）。
+// 直接以 jobCore 为底：它已经处理了 --contract / --engines / --sessions 探测分支。
+func autoHTTPCore(t *testing.T, verdict string) string {
+	t.Helper()
+	base := jobCore(t)
+	b, err := os.ReadFile(base)
+	if err != nil {
+		t.Fatal(err)
+	}
+	branch := "case \"$*\" in\n  *--judge-conflict*)\n    cat >/dev/null\n    echo '" + verdict + "'\n    exit 0\n    ;;\n"
+	out := strings.Replace(string(b), "case \"$*\" in\n", branch, 1)
+	if out == string(b) {
+		t.Fatal("没找到 jobCore 的 case 分支，判定 core 打桩失败")
+	}
+	path := filepath.Join(t.TempDir(), "magic-agent")
+	if err := os.WriteFile(path, []byte(out), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	return path
+}
+
+// 端到端（HTTP 层）：mode=auto 的请求要原样落进作业记录，判定结论要能被客户端读到。
+func TestAutoModeOverHTTP(t *testing.T) {
+	ws := t.TempDir()
+	core := autoHTTPCore(t, `{"conflict":true,"level":"hard","reason":"都要改 index.html","overlaps":["index.html"]}`)
+	svc, _ := jobTestService(t, core)
+	base := httptest.NewServer(svc.Handler())
+	defer base.Close()
+	writeRunningSession(t, ws, "run-busy", "sess-busy", "改底部栏")
+
+	job := postJob(t, base.URL, map[string]any{
+		"engine": "claude", "prompt": "改底部栏配色", "workspace": ws, "mode": "auto",
+	})
+	if job.Mode != "auto" {
+		t.Fatalf("作业应记住 mode=auto，实际 %q", job.Mode)
+	}
+
+	got := waitJob(t, base.URL, job.ID, func(j *Job) bool {
+		return j.Auto != nil && j.Auto.By == "model"
+	}, 5*time.Second)
+	if !got.Serial {
+		t.Fatalf("模型判冲突应串行，实际 serial=false（auto=%+v）", got.Auto)
+	}
+	if !strings.Contains(got.Auto.Reason, "index.html") {
+		t.Errorf("理由应带冲突点，实际 %q", got.Auto.Reason)
+	}
+	if got.Mode != "auto" {
+		t.Errorf("GET 也要带 mode，实际 %q", got.Mode)
+	}
+}
+
+// 显式模式必须**说了算**（2026-10-26 用户：「模式判断要拦截每个会话，如果不是
+// 自动就按选择模式处理」）：只发 mode、不发 serial 时不能被缺省串行吃掉。
+func TestExplicitModeWinsOverSerialFlag(t *testing.T) {
+	cases := []struct {
+		name   string
+		mode   string
+		serial *bool
+		want   bool
+	}{
+		{"parallel 不管 serial=true", "parallel", boolPtr(true), false},
+		{"parallel 不带 serial", "parallel", nil, false},
+		{"serial 不管 serial=false", "serial", boolPtr(false), true},
+		{"serial 不带 serial", "serial", nil, true},
+		{"auto 不消费 serial（走判定）", "auto", boolPtr(true), false},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			ws := t.TempDir()
+			q := autoTestQueue(t, ws)
+			j, _, err := q.submitAsk(askRequest{
+				Prompt: "跑一下", Workspace: ws, Mode: c.mode, Serial: c.serial,
+			}, "claude", "pc")
+			if err != nil {
+				t.Fatalf("submitAsk: %v", err)
+			}
+			if j.Serial != c.want {
+				t.Fatalf("mode=%q serial=%v → Serial=%v，期望 %v", c.mode, c.serial, j.Serial, c.want)
+			}
+			if c.mode != "auto" && j.Mode != c.mode {
+				t.Fatalf("mode=%q 没记到作业上，实际 %q", c.mode, j.Mode)
+			}
+		})
+	}
+}