magic-agent 1.0.3 → 1.0.46

package/internal/cli/sessionlog_user_test.go

@@ -3,10 +3,13 @@ package cli
 import (
 	"context"
 	"encoding/json"
+	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 
 	"github.com/darren/magic-agent/internal/agent"
+	"github.com/darren/magic-agent/internal/session"
 )
 
 // 用户提问落盘（kind:"user"）的端到端验证。
@@ -57,7 +60,9 @@ func TestStreamAskPersistsUserMessage(t *testing.T) {
 	const prompt = "帮我把 guard 的令牌比较改成常数时间，避免时序侧信道"
 	registerFake(&userEchoStreamEngine{name: "fake-user-log", sessionID: sid})
 
-	if _, _, err := runAskCmd(t, "", "-e", "fake-user-log", "--stream", prompt); err != nil {
+	// --save-history：落盘存档是** opt-in** 的（默认关，见 TestStreamAskNoArchiveByDefault），
+	// 这一条要验的是「开了之后落盘内容对不对」，所以显式传。
+	if _, _, err := runAskCmd(t, "", "-e", "fake-user-log", "--stream", "--save-history", prompt); err != nil {
 		t.Fatalf("--stream: %v", err)
 	}
 
@@ -117,6 +122,142 @@ func TestStreamAskPersistsUserMessage(t *testing.T) {
 	}
 }
 
+// TestStreamAskNoArchiveByDefault **默认什么都不存**（用户 2026-10-12：
+// 「加一个参数 默认不存档」+「会话登记也不需要」）。
+//
+// 这一条钉住**默认值本身**：不加 --save-registry / --save-history 时，一次跑完的流式
+// 会话不该在磁盘上留下任何痕迹 —— 既没有登记表 <run_id>.json，也没有历史 <session_id>.jsonl。
+// 落盘是副作用，而绝大多数调用（CLI 手工跑一轮、CI、脚本编排）事后没人寻址。
+//
+// 反面同样重要：流本身必须照常跑完（不存档 ≠ 不干活）。
+func TestStreamAskNoArchiveByDefault(t *testing.T) {
+	dir := t.TempDir()
+	prev := SessionLogDirOverride
+	SessionLogDirOverride = dir
+	defer func() { SessionLogDirOverride = prev }()
+	regDir := t.TempDir()
+	t.Setenv(session.EnvDir, regDir)
+
+	const sid = "sess-no-archive"
+	registerFake(&userEchoStreamEngine{name: "fake-no-archive", sessionID: sid})
+
+	stdout, _, err := runAskCmd(t, "", "-e", "fake-no-archive", "--stream", "跑一轮")
+	if err != nil {
+		t.Fatalf("默认不存档不该让流失败：%v", err)
+	}
+	if !strings.Contains(stdout, "收到") {
+		t.Errorf("流式输出应照常有正文，实际 %q", stdout)
+	}
+	// 历史存档不该有：磁盘上没有文件，读端对「文件不在」静默返回空，所以两者都要钉。
+	if _, err := os.Stat(filepath.Join(dir, sid+".jsonl")); !os.IsNotExist(err) {
+		t.Errorf("默认不该落历史存档（stat err=%v）", err)
+	}
+	if evs, err := ReadSessionLog(dir, sid); err != nil || len(evs) != 0 {
+		t.Errorf("默认不该有可回放历史：%d 条 (err=%v)", len(evs), err)
+	}
+	// 会话登记也不该有 —— 这条会话不该出现在 --sessions / --stop 的视野里。
+	ents, _ := os.ReadDir(regDir)
+	for _, e := range ents {
+		if strings.HasSuffix(e.Name(), ".json") {
+			t.Errorf("默认不该落会话登记，却有 %s", e.Name())
+		}
+	}
+	recs, err := session.List()
+	if err != nil {
+		t.Fatalf("List: %v", err)
+	}
+	if len(recs) != 0 {
+		t.Errorf("默认不该落会话登记，实际 %d 条：%+v", len(recs), recs)
+	}
+}
+
+// TestStreamAskSavesBothWhenAsked 两个开关都显式打开时，登记表与历史存档都要落。
+// 它与 TestStreamAskNoArchiveByDefault 成对：一条钉默认关，一条钉开了确实有用。
+func TestStreamAskSavesBothWhenAsked(t *testing.T) {
+	dir := t.TempDir()
+	prev := SessionLogDirOverride
+	SessionLogDirOverride = dir
+	defer func() { SessionLogDirOverride = prev }()
+	regDir := t.TempDir()
+	t.Setenv(session.EnvDir, regDir)
+
+	const sid = "sess-saved"
+	registerFake(&userEchoStreamEngine{name: "fake-saved", sessionID: sid})
+
+	if _, _, err := runAskCmd(t, "", "--save-registry", "--save-history",
+		"-e", "fake-saved", "--stream", "跑一轮"); err != nil {
+		t.Fatalf("--stream: %v", err)
+	}
+	evs, err := ReadSessionLog(dir, sid)
+	if err != nil || len(evs) == 0 {
+		t.Fatalf("开了 --save-history 就该有可回放历史：%d 条 (err=%v)", len(evs), err)
+	}
+	recs, err := session.List()
+	if err != nil || len(recs) != 1 || recs[0].SessionID != sid {
+		t.Fatalf("开了 --save-registry 就该落一条登记：%+v (err=%v)", recs, err)
+	}
+}
+
+// midRunRegistryEngine 在流的**中途**回头看一眼登记表。
+//
+// 为什么需要它：登记表的 SessionID 以前只在**收尾**（Handle.Finish）才写，于是「正在跑的
+// 会话」在磁盘上只有 run_id —— 客户端的会话列表按 session_id 去重会在这段时间失效
+// （同一段对话以 run_id 为键裂成两条），点开这样的行回传的也是 run_id（引擎不认识 →
+// 续接接不上 / 另起一段）。这一条钉住「引擎报出 id 的那一刻，登记表里就有它」。
+type midRunRegistryEngine struct {
+	name      string
+	sessionID string
+	found     *bool // 流中途（收尾之前）拿到的那次读结果
+	rec       *session.Record
+}
+
+func (e *midRunRegistryEngine) Name() string           { return e.name }
+func (e *midRunRegistryEngine) Detect() (bool, string) { return true, "fake://" + e.name }
+
+func (e *midRunRegistryEngine) Complete(_ context.Context, _ agent.Request) (agent.Response, error) {
+	return agent.Response{Text: "收到", Model: "fake-model"}, nil
+}
+
+func (e *midRunRegistryEngine) Stream(_ context.Context, req agent.Request, onEvent func(agent.StreamEvent)) (agent.StreamResult, error) {
+	// 引擎流里报出 session_id 的那一刻（真实引擎在 init 行里报）。
+	if req.OnSessionID != nil {
+		req.OnSessionID(e.sessionID)
+	}
+	// 流还没结束 —— 此刻登记表里就应该已经有这个会话 id。
+	if rec, ok, err := session.Find(e.sessionID); err == nil && ok {
+		*e.found = true
+		*e.rec = rec
+	}
+	onEvent(agent.StreamEvent{Kind: agent.KindText, Text: "收到", SessionID: e.sessionID})
+	return agent.StreamResult{
+		Response: agent.Response{Engine: e.name, Text: "收到", Model: "fake-model", SessionID: e.sessionID},
+	}, nil
+}
+
+func TestStreamAskBackfillsSessionIDMidRun(t *testing.T) {
+	regDir := t.TempDir()
+	t.Setenv(session.EnvDir, regDir)
+
+	const sid = "sess-mid-run"
+	found := false
+	var seen session.Record
+	registerFake(&midRunRegistryEngine{name: "fake-mid-run", sessionID: sid, found: &found, rec: &seen})
+
+	if _, _, err := runAskCmd(t, "", "--save-registry", "-e", "fake-mid-run", "--stream", "跑一轮"); err != nil {
+		t.Fatalf("--stream: %v", err)
+	}
+
+	// ① 流**中途**（收尾之前）登记表里就该有这条会话的 session_id。
+	if !found || seen.SessionID != sid {
+		t.Fatalf("引擎报出 id 之后就该回填登记表（收尾前读不到会让正在跑的会话只有 run_id）：found=%v rec=%+v", found, seen)
+	}
+	// ② 收尾后仍在，且不会被覆盖成别的值。
+	recs, err := session.List()
+	if err != nil || len(recs) != 1 || recs[0].SessionID != sid {
+		t.Fatalf("收尾后登记表应仍是这一条：%+v (err=%v)", recs, err)
+	}
+}
+
 func dumpKinds(evs []sessionEvent) string {
 	out := ""
 	for i, ev := range evs {

package/internal/cli/sessiontitle.go

@@ -0,0 +1,141 @@
+package cli
+
+// sessiontitle.go - `--summarize-title <id>`：把一条会话的首问归纳成标题。
+//
+// 为什么这条命令存在（用户 2026-10-15：「应该 magic-agent 统一归纳作为会话标题」）：
+// 归纳此前只有业务项目（掌天瓶）在做，core 侧只有一张空的 sid→title 覆盖表 —— 于是
+// 同一会话在 PC 与移动端显示**不同的标题**（PC 是本地归纳的要点，移动端回落 prompt_head
+// 首问原文），而且**从移动端发起的会话没人替它归纳**。
+// 把归纳收进 core 之后，归纳口径只有一份（internal/session/title.go），两端只读不自己算。
+//
+// 与 `--sessions` / `--session-log` / `--stop` 同一套思路：会话数据的读写都做成 CLI 命令，
+// 调用方 exec 即可，不必碰本仓库的磁盘格式（core 不跑服务，见 CLIENT-CONTRACT §3.4）。
+//
+// 覆盖表沿用插件时期落的同一个文件（~/.magic-agent/session-titles.json），换实现不换路径。
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	"github.com/darren/magic-agent/internal/session"
+)
+
+// runSummarizeTitle 归纳一条会话的标题：`--summarize-title <session_id|run_id>`。
+//
+// 输入取自**会话自己的历史**（首条 user 消息，见 session.FirstUserText）——
+// 调用方不用把首问原文再传一遍，两端也就不会因为「谁截断的」而归纳出不同标题。
+//
+// 退出码：
+//
+//	0  归纳成功（或本来就已归纳，直接回现有标题：cached=true）
+//	1  归纳失败（引擎不可用 / 读不到会话 / 模型没给出可用标题）
+//	2  参数错（空 id）
+func runSummarizeTitle(cmd *cobra.Command, opts *askOptions) error {
+	id := strings.TrimSpace(opts.summarizeTitle)
+	if id == "" {
+		return &usageError{fmt.Errorf("--summarize-title 需要会话 id：传 session_id 或 run_id（--sessions 可列出全部）")}
+	}
+
+	// 定位会话：登记表里认这条（拿 session_id / prompt_head）。认不到**不算错** ——
+	// 只有 `--save-registry`（插件 / 客户端恒传）才落登记表，手工直跑 CLI 与 CI 那种
+	// 不留档的调用压根没有记录，所以「昨天跑过、今天仍想归纳」的会话在这里可能认不到。
+	rec, found, _ := session.Find(id)
+	sessionID, runID := rec.SessionID, rec.RunID
+	if !found {
+		/* 认不到时把传进来的 id 同时当 session_id 与 run_id 用：
+		   · 日志按 **session_id** 命名 —— 用 id 去读日志，读到了就说明它本来就是 session_id
+		     （存量会话多半是这种：旧日志都在，只是登记表清了）；
+		   · 读不到也没损失（run_id 那种新会话首轮本来就没日志）。 */
+		sessionID, runID = id, id
+	}
+	key := sessionID
+	if key == "" {
+		key = runID
+	}
+
+	/* 已有归纳结果且没要求重来 → 直接回，省一次 LLM 调用。
+	   ⚠️ **两个键都认**（2026-10-15，用户：「标题只在第一次创建时生成」）：首轮归纳时
+	   引擎可能还没吐 session_id，那时键落在 run_id 上；而 run_id **每轮追问都换一个** →
+	   只按 session_id 查会判成「还没归纳」，于是每轮重算一次，标题就跟着最新那条追问走
+	   （A 端 B 端各自刷新到的时刻不同，还会显示得不一样）。
+	   命中时顺手把标题迁到 session_id 上，此后键固定、标题不再变。 */
+	if !opts.titleForce {
+		/* 命中判定要认**三个来源**：
+		   ① 这个 id 直接建的覆盖；② 这条会话当前的 run_id（首轮归纳时还没 session_id）；
+		   ③ 这条会话**其他轮**的 run_id —— 只认前两个的话，存量会话会被判成「还没归纳」，
+		      于是把标题**重写一遍**（AI 归纳是独立调用，重写出来的字还不一样）。 */
+		t := session.TitleForAny(sessionID, runID)
+		if t == "" {
+			t = session.TitleForSessionRuns(sessionID)
+		}
+		if t != "" {
+			// 顺手归一：值不动，但把这条会话各轮 run_id 上的旧键清掉、只留 session_id。
+			_ = session.ConsolidateTitle(sessionID, runID, t)
+			return printJSON(cmd.OutOrStdout(), session.SummaryResult{ID: key, Title: t, Cached: true})
+		}
+	}
+
+	/* 首问从**会话历史**里取 —— 归纳的输入必须是这条会话的**第一句**，否则标题会跟着
+	   最新那条追问走（这正是「每次追问标题都在变」的来源）。
+	   ① 日志名可能是 session_id（终名），也可能是 run_id（引擎还没吐 id 时先按它落盘）
+	      → 先用 ResolveLogID 翻一次名；
+	   ② **不再拿 prompt_head 当兜底**：它记的是**当前这一轮**的提示词，追问轮用它归纳
+	      等于把标题改成最新追问的要点。只有这条会话还没有 session_id（= 首轮，
+	      prompt_head 就是首问）时才允许用它兜底。
+	   ⚠️ 目录必须显式取 —— 传空串会退化成相对路径、在 cwd 下找（这条踩过）。 */
+	logDir, _ := sessionLogDir()
+	first := session.FirstUserText(logDir, session.ResolveLogID(logDir, key), "")
+	if strings.TrimSpace(first) == "" {
+		if sessionID == "" {
+			first = rec.PromptHead // 首轮且没日志：prompt_head 就是首问
+		}
+	}
+	if strings.TrimSpace(first) == "" {
+		return fmt.Errorf("--summarize-title %s: 读不到这条会话的**首问**（没有事件日志）——"+
+			"标题只按首问归纳，不拿当前这轮的提示词凑数（否则标题会跟着追问变）；"+
+			"该会话要用 --save-history 跑过才归纳得动", id)
+	}
+
+	res, err := session.Summarize(cmd.Context(), session.SummarizeOptions{
+		SessionID: sessionID,
+		RunID:     runID,
+		Text:      first,
+		Engine:    opts.titleEngine,
+		Force:     true, // 上面已处理过缓存分支，到这里必然要真归纳
+	})
+	if err != nil {
+		return fmt.Errorf("--summarize-title %s: 归纳失败: %w", id, err)
+	}
+	return printJSON(cmd.OutOrStdout(), res)
+}
+
+// runSessionTitle 读一条会话的**已存**标题（不调 LLM）：`--session-title <id>`。
+//
+// 为什么要单独一条读命令：列表页要为每行取标题，逐行调 `--summarize-title` 会把
+// 每行都变成一次 LLM 调用。有了覆盖表之后，「读」必须能单独走（GET /desk/titles 同理）。
+func runSessionTitle(cmd *cobra.Command, opts *askOptions) error {
+	id := strings.TrimSpace(opts.sessionTitle)
+	if id == "" {
+		return &usageError{fmt.Errorf("--session-title 需要会话 id：传 session_id 或 run_id")}
+	}
+	t := session.TitleFor(id)
+	if t == "" {
+		/* 没有直接用这个 id 建的覆盖 → 认登记表里的**两个键**（session_id / run_id）：
+		   首轮归纳时引擎可能还没吐 session_id，键落在那一轮的 run_id 上（见 TitleForAny）。
+		   不认它的话，按 session_id 读会回落成 prompt_head（= **当前这轮**的提示词），
+		   于是同一会话在两个客户端上显示成不同标题。 */
+		rec, found, _ := session.Find(id)
+		if found {
+			t = session.TitleForAny(rec.SessionID, rec.RunID)
+			if t == "" {
+				t = rec.PromptHead // 没归纳过 = 回落到首问原文。
+			}
+		}
+	}
+	return printJSON(cmd.OutOrStdout(), struct {
+		ID    string `json:"id"`
+		Title string `json:"title"`
+	}{ID: id, Title: t})
+}