magic-agent 1.0.2 → 1.0.46

package/internal/session/title.go

@@ -0,0 +1,486 @@
+// title.go - 会话标题的**统一存储与归纳**（2026-10-15）。
+//
+// 为什么标题归 core（用户：「应该 magic-agent 统一归纳作为会话标题」）：
+// 此前归纳逻辑只在业务项目（掌天瓶）里，而标题存储在插件里 —— 于是 PC 与移动端
+// 各算各的：PC 显示本地 AI 归纳的要点，移动端只能回落 prompt_head（首问原文）。
+// 同一会话在两端显示不同标题，且**从移动端发起的会话没人替它归纳**。
+// 现在口径收成一份：归纳在这里、存储也在这里，客户端只读不自己算。
+//
+// 两层结构，边界要清楚：
+//
+//	· 存储（sid→title 覆盖表）是**纯数据**，无依赖、幂等，任何客户端都能读写；
+//	· 归纳（Summarize）是**调引擎**，只在这里做，客户端不重复实现。
+//
+// 覆盖表沿用插件时期落的同一个文件（~/.magic-agent/session-titles.json）——
+// 换实现不换路径，用户已有的重命名结果不丢。
+package session
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/darren/magic-agent/internal/agent"
+)
+
+// TitleMaxChars 归纳标题的硬上限（汉字个数）。与业务项目时期的口径一致（≤12 字）。
+const TitleMaxChars = 12
+
+// titlePromptCap 送进 prompt 的原文上限：首问可能很长（含需求正文 / 粘贴的整段文本），
+// 而「标题」只需要知道这件事在做什么。截断只影响模型看到的原文，不影响任何落盘数据。
+const titlePromptCap = 2000
+
+var (
+	titleMu     sync.Mutex
+	titleCache  map[string]string
+	titleLoaded bool
+)
+
+// TitleStorePath 覆盖表路径（~/.magic-agent/session-titles.json）。
+// 与会话登记表同在 .magic-agent 下 —— 换实现不换路径，见文件头。
+func TitleStorePath() (string, error) {
+	if p := strings.TrimSpace(os.Getenv(EnvDir)); p != "" {
+		return filepath.Join(filepath.Dir(p), "session-titles.json"), nil
+	}
+	home, err := os.UserHomeDir()
+	if err != nil || home == "" {
+		return "", os.ErrNotExist
+	}
+	return filepath.Join(home, ".magic-agent", "session-titles.json"), nil
+}
+
+// loadTitles 读覆盖表（文件不存在 = 空表，不是错误）。
+// 进程内缓存一份：列表页会逐行问标题，逐行读盘没必要；
+// 写操作（SetTitle）后缓存失效，保证同一进程内也读到新值。
+func loadTitles() (map[string]string, error) {
+	titleMu.Lock()
+	defer titleMu.Unlock()
+	if titleLoaded {
+		out := make(map[string]string, len(titleCache))
+		for k, v := range titleCache {
+			out[k] = v
+		}
+		return out, nil
+	}
+	out := map[string]string{}
+	p, err := TitleStorePath()
+	if err != nil {
+		titleCache, titleLoaded = out, true
+		return out, nil
+	}
+	if b, err := os.ReadFile(p); err == nil {
+		_ = json.Unmarshal(b, &out)
+	}
+	titleCache, titleLoaded = out, true
+	return out, nil
+}
+
+func saveTitlesLocked(m map[string]string) error {
+	p, err := TitleStorePath()
+	if err != nil {
+		return err
+	}
+	if err := os.MkdirAll(filepath.Dir(p), 0o700); err != nil {
+		return err
+	}
+	b, err := json.MarshalIndent(m, "", "  ")
+	if err != nil {
+		return err
+	}
+	if err := os.WriteFile(p, b, 0o600); err != nil {
+		return err
+	}
+	titleCache, titleLoaded = m, true
+	return nil
+}
+
+// Titles 返回整份覆盖表（GET /desk/titles 给客户端合并用）。
+func Titles() map[string]string {
+	m, _ := loadTitles()
+	return m
+}
+
+// TitleFor 取一条会话的覆盖标题（没有则空串）。
+func TitleFor(id string) string {
+	id = strings.TrimSpace(id)
+	if id == "" {
+		return ""
+	}
+	m, _ := loadTitles()
+	return m[id]
+}
+
+// TitleForAny 取一条会话的覆盖标题：**session_id 优先，其次 run_id**。
+//
+// 为什么需要「认两个键」（2026-10-15 用户：「会话标题每次追问也在更新，只在第一次
+// 创建时生成就好」）：标题的键是**归纳那一刻**能拿到的 id —— 首轮归纳时引擎可能还没吐
+// session_id，于是键落在 run_id 上；而 run_id **每轮追问都换一个**，下一轮按 session_id
+// 一查就查不到 → 客户端以为「还没归纳」→ 再归纳一次（且输入回落成最新那条追问的原文）
+// → 标题每轮都在变，PC 与移动端各自刷新到的时刻不同，还显示得不一样。
+// 两个键都认之后，老的 run_id 键也命中；调用方顺手用 AdoptTitle 把它迁到 session_id 上，
+// 从此键就固定了。
+func TitleForAny(sessionID, runID string) string {
+	m, _ := loadTitles()
+	if t := m[strings.TrimSpace(sessionID)]; t != "" {
+		return t
+	}
+	return m[strings.TrimSpace(runID)]
+}
+
+// AdoptTitle 把标题从 run_id 迁到 session_id（幂等），并**清掉那个 run_id 键**。
+//
+// 只在新键**为空**时搬：用户可能已经手动重命名过（那就是权威值），不能被旧键覆盖回去。
+// 两个 id 相同、任一为空、或旧键没有标题时都是空操作。
+//
+// ⚠️ 搬完要删旧键：留着它就等于同一会话有两个键、两个值 ——
+// 谁按 session_id 读、谁按 run_id 读，就会看到**两个不同的标题**（PC 与移动端不一致的
+// 一个直接来源，实测踩到过）。
+func AdoptTitle(sessionID, runID string) {
+	sid, rid := strings.TrimSpace(sessionID), strings.TrimSpace(runID)
+	if sid == "" || rid == "" || sid == rid {
+		return
+	}
+	m, _ := loadTitles()
+	if m[sid] == "" && m[rid] != "" {
+		_ = SetTitle(sid, m[rid])
+	}
+	dropRunTitle(rid, sid)
+}
+
+// ConsolidateTitle 写标题，并把这条会话**归一到一个键**上：值写给 session_id，
+// 该会话各轮 run_id 上的旧键一并清掉。
+//
+// 为什么要归一：首轮归纳时引擎可能还没吐 session_id，键于是落在那一轮的 run_id 上；而
+// run_id 每轮追问都换 → 同一会话会攒出一串键，且**值还可能不同**（每次归纳是独立的 LLM 调用）。
+// 结果就是「同一会话按不同 id 读，标题不一样」。
+//
+// sessionID 为空（引擎始终没给 id）时只能挂在 runID 上 —— 那种会话本来就每轮一行。
+func ConsolidateTitle(sessionID, runID, title string) error {
+	sid := strings.TrimSpace(sessionID)
+	if sid == "" {
+		return SetTitle(runID, title)
+	}
+	if err := SetTitle(sid, title); err != nil {
+		return err
+	}
+	dropSessionRunTitles(sid)
+	return nil
+}
+
+// dropRunTitle 删掉一个 run_id 键（同 sid 时不动）。
+func dropRunTitle(runID, sessionID string) {
+	rid := strings.TrimSpace(runID)
+	if rid == "" || rid == strings.TrimSpace(sessionID) {
+		return
+	}
+	if TitleFor(rid) != "" {
+		_ = SetTitle(rid, "")
+	}
+}
+
+// dropSessionRunTitles 清掉这条会话**各轮 run_id** 上的标题键（保留 session_id 那个）。
+//
+// 名单取自登记表（每轮一条记录）。登记表清掉的陈年 run 键就留着了 —— 那时它已经不可达
+// （没有记录指向它，客户端拿不到那个 id），无副作用。
+func dropSessionRunTitles(sessionID string) {
+	recs, err := List()
+	if err != nil {
+		return
+	}
+	for _, r := range recs {
+		if r.SessionID != sessionID {
+			continue
+		}
+		dropRunTitle(r.RunID, sessionID)
+	}
+}
+
+// TitleForSessionRuns 在这条会话**各轮 run_id** 上找已有标题（没找到回空串）。
+//
+// 为什么需要：首轮归纳时引擎可能还没吐 session_id，标题就挂在那一轮的 run_id 上；而
+// 追问轮的当前 run_id 是**另一个**。只认「session_id + 当前 run_id」的话，会判成
+// 「还没归纳」→ 把这条会话的标题**重写一遍**（用户 2026-10-15 报的「每次追问也在更新标题」
+// 就是这个现象；AI 归纳是独立调用，重写出来的字还会不一样）。
+//
+// 取**最早**的那一轮（登记表按 StartedAt 倒序，所以倒着扫）：那是「这条会话第一次
+// 生成标题」的结果，符合「只在第一次创建时生成」的期望。
+func TitleForSessionRuns(sessionID string) string {
+	sid := strings.TrimSpace(sessionID)
+	if sid == "" {
+		return ""
+	}
+	recs, err := List()
+	if err != nil {
+		return ""
+	}
+	for i := len(recs) - 1; i >= 0; i-- {
+		r := recs[i]
+		if r.SessionID != sid || r.RunID == sid {
+			continue
+		}
+		if t := TitleFor(r.RunID); t != "" {
+			return t
+		}
+	}
+	return ""
+}
+
+// SetTitle 设置/清除一条会话的标题（空标题 = 清除覆盖，回到 prompt_head）。
+//
+// 并发写：两个客户端同时重命名，后写的整表覆盖会丢掉对方那条。
+// 所以读-改-写全程持锁，并且**每次都重新从磁盘读**再合并 ——
+// 拿进程内缓存去写会把另一个进程刚写的条目抹掉（插件时代就有这个洞）。
+func SetTitle(id, title string) error {
+	id = strings.TrimSpace(id)
+	if id == "" {
+		return os.ErrInvalid
+	}
+	titleMu.Lock()
+	defer titleMu.Unlock()
+	p, err := TitleStorePath()
+	if err != nil {
+		return err
+	}
+	onDisk := map[string]string{}
+	if b, err := os.ReadFile(p); err == nil {
+		_ = json.Unmarshal(b, &onDisk)
+	}
+	t := strings.TrimSpace(title)
+	if t == "" {
+		delete(onDisk, id)
+	} else {
+		onDisk[id] = t
+	}
+	return saveTitlesLocked(onDisk)
+}
+
+// ── 归纳 ──────────────────────────────────────────────────────────────────
+
+// buildTitlePrompt 归纳提示词。
+//
+// 规则与业务项目时期的 buildTitlePrompt 逐字一致（≤12 字、产品经理视角要点、
+// 只输出标题本身）—— 换实现不换口径，否则同一句话在两端会归纳出不同标题。
+func buildTitlePrompt(text string, max int) string {
+	return strings.Join([]string{
+		"你是资深产品经理。把下面这段「用户发给助手的第一句话」归纳成一句话要点，作为这条对话的标题。",
+		"要求：",
+		"1. 用中文，不超过 " + strconv.Itoa(max) + " 个汉字；",
+		"2. 是产品经理视角的要点（说清「做什么 / 要达成什么」），不要照抄原句、不要写整段话；",
+		"3. 不要标点符号、引号、书名号、序号，不要换行；",
+		"4. 不要任何解释，也不要「标题：」这类前缀 —— 只输出标题本身。",
+		"",
+		"用户的话：" + truncateRunes(strings.TrimSpace(text), titlePromptCap),
+	}, "\n")
+}
+
+// normalizeTitle 归一化模型输出：取首个非空行 → 剥前缀/引号/序号 → 收尾标点 → 硬截断。
+// 模型偶发不听话（「标题：xxx」「1. xxx」「“xxx”」「xxx。」）都在这里收口。
+//
+// 收口用正则而不是逐层 TrimPrefix：前缀形态太多（`标题：` `标题 - ` `**标题：**` …），
+// 逐个试会把「标题设计评审」这种**本身就以「标题」开头**的正常标题误剥。
+func normalizeTitle(raw string, max int) string {
+	first := ""
+	for _, line := range strings.Split(raw, "\n") {
+		if s := strings.TrimSpace(stripFence(line)); s != "" {
+			first = s
+			break
+		}
+	}
+	return trimTitleTail(truncateRunes(stripTitleDecor(first), max))
+}
+
+var (
+	reFence = regexp.MustCompile("^```[a-zA-Z]*$")
+	// 前缀有两种形态，分开认（一条正则写不干净）：
+	//   ① **带分隔符**：标题：/ 标题: / 标题 - / **标题：**
+	//   ② **括号包裹**：【标题】/ [标题] / （标题） —— 括号后面**没有**分隔符，
+	//      若强求分隔符，这条就不匹配，剥完前缀会剩一个「标题】」。
+	// 分开写才不会为了统一而让其中一种剥不掉。
+	reTitlePreColon = regexp.MustCompile(`^(?:\*\*)?\s*(?:需求)?(?:标题|题目|title)\s*(?:\*\*)?\s*[:：\-—]\s*`)
+	reTitlePreBrack = regexp.MustCompile(`^(?:\*\*)?\s*[【\[（(]\s*(?:需求)?(?:标题|题目|title)\s*[】\]）)]\s*(?:\*\*)?\s*`)
+	reMarkdown      = regexp.MustCompile(`^[#>\-*·]+\s*`)
+	reLeadingNum    = regexp.MustCompile(`^\d+\s*[.、)）:：]\s*`)
+	reOpenQuote     = regexp.MustCompile(`^[「『“”‘’"'《【\[(（]+\s*`)
+	reCloseQuote    = regexp.MustCompile(`\s*[」』“”‘’"'》】\])）]+$`)
+	reTailPunct     = regexp.MustCompile(`[。，、；：！？,.;:!?~～\s]+$`)
+)
+
+// stripFence 剥模型爱加的 ``` 代码围栏（只处理整行就是围栏的情形）。
+func stripFence(line string) string {
+	s := strings.TrimSpace(line)
+	if reFence.MatchString(s) {
+		return ""
+	}
+	return s
+}
+
+// stripTitleDecor 剥「标题：」这类前缀、markdown 记号、序号、开引号。
+func stripTitleDecor(s string) string {
+	s = strings.TrimSpace(s)
+	// 两种前缀各试一次：它们互斥（有没有分隔符），所以顺序无关。
+	s = reTitlePreColon.ReplaceAllString(s, "")
+	s = reTitlePreBrack.ReplaceAllString(s, "")
+	s = reMarkdown.ReplaceAllString(s, "")
+	s = reLeadingNum.ReplaceAllString(s, "")
+	return strings.TrimSpace(reOpenQuote.ReplaceAllString(s, ""))
+}
+
+func trimTitleTail(s string) string {
+	s = reCloseQuote.ReplaceAllString(s, "")
+	return strings.TrimSpace(reTailPunct.ReplaceAllString(s, ""))
+}
+
+func truncateRunes(s string, n int) string {
+	r := []rune(s)
+	if len(r) <= n {
+		return s
+	}
+	return string(r[:n])
+}
+
+// FirstUserText 取一条会话**首条 user 消息**的正文（标题归纳的输入）。
+//
+// 优先读事件日志（--save-history 落的那份，含真实首问）；读不到再回落登记表的
+// prompt_head（它就是首问的前 80 字，够归纳用）。日志优先是因为 prompt_head 被
+// 截断过，长首问会归纳不出要点。
+//
+// ⚠️ dir 传空 = 用默认会话目录（Dir()），**不要**让空串退化成相对路径 ——
+// 那会在 cwd 下找 `<id>.jsonl`，于是「日志明明在也读不到」，白跑一次 LLM。
+func FirstUserText(dir, sessionID, promptHead string) string {
+	if strings.TrimSpace(dir) == "" {
+		dir = Dir()
+	}
+	if s := strings.TrimSpace(sessionID); s != "" && dir != "" {
+		if b, err := os.ReadFile(filepath.Join(dir, s+".jsonl")); err == nil {
+			for _, line := range strings.Split(string(b), "\n") {
+				line = strings.TrimSpace(line)
+				if line == "" {
+					continue
+				}
+				var ev struct {
+					Kind string `json:"kind"`
+					Text string `json:"text"`
+				}
+				if json.Unmarshal([]byte(line), &ev) != nil {
+					continue
+				}
+				if ev.Kind == "user" && strings.TrimSpace(ev.Text) != "" {
+					return ev.Text
+				}
+			}
+		}
+	}
+	return promptHead
+}
+
+// Summarize 为一条会话归纳标题并写进覆盖表。
+//
+// 为什么在 core 里跑 LLM（而不是让各客户端各自归纳）：这是「统一口径」的唯一实现点。
+// 用 `llm` 引擎（纯文本、无工具）—— 与业务项目归纳需求标题时用的是同一个引擎，
+// 所以同一句话在两端会得到同一个标题。
+//
+// 超长再压一次（实测模型偶发给 13 字，硬截断会把「保持一致」切成「保持一」）。
+// 失败**不抛**：调用方多在用户点击的同步路径上，抛出去就是没有反馈的死点击；
+// 返回 ok=false 让界面保留已有的临时标题。
+//
+// 已经归纳过（有覆盖）且 force=false → 直接返回现有标题，不再调 LLM。
+func Summarize(ctx context.Context, opts SummarizeOptions) (SummaryResult, error) {
+	sessionID := strings.TrimSpace(opts.SessionID)
+	runID := strings.TrimSpace(opts.RunID)
+	if sessionID == "" && runID == "" {
+		return SummaryResult{}, os.ErrInvalid
+	}
+	key := sessionID
+	if key == "" {
+		key = runID
+	}
+	if !opts.Force {
+		// ⚠️ 两个键都认（session_id / run_id）：老的键可能落在上一轮的 run_id 上，
+		// 只认 session_id 会判成「还没归纳」→ 每轮重算（标题就跟着追问变）。
+		// 命中时顺手把标题迁到 session_id 上，此后键固定。
+		// 命中时顺手把键归一（值不动）：老的 run_id 键清掉、只留 session_id ——
+		// 留着两把键，按不同 id 读就会拿到不同标题。
+		if t := TitleForAny(sessionID, runID); t != "" {
+			_ = ConsolidateTitle(sessionID, runID, t)
+			return SummaryResult{ID: key, Title: t, Cached: true}, nil
+		}
+		// 本会话**其他轮**的 run 键（首轮归纳时还没 session_id）也算命中 ——
+		// 否则会把已经有的标题重写一遍。
+		if t := TitleForSessionRuns(sessionID); t != "" {
+			_ = ConsolidateTitle(sessionID, runID, t)
+			return SummaryResult{ID: key, Title: t, Cached: true}, nil
+		}
+	}
+	src := strings.TrimSpace(opts.Text)
+	if src == "" {
+		return SummaryResult{}, os.ErrNotExist
+	}
+	engineName := strings.TrimSpace(opts.Engine)
+	if engineName == "" {
+		engineName = "llm"
+	}
+	engine := agent.Lookup(engineName)
+	if engine == nil {
+		return SummaryResult{}, os.ErrNotExist
+	}
+	timeout := opts.Timeout
+	if timeout <= 0 {
+		timeout = 60 * time.Second
+	}
+	run := func(max int, extra string) (string, error) {
+		cctx, cancel := context.WithTimeout(ctx, timeout)
+		defer cancel()
+		runner := &agent.Runner{Engine: engine, Timeout: timeout}
+		resp, err := runner.Run(cctx, agent.Request{
+			Messages: []agent.Message{{Role: "user", Content: buildTitlePrompt(src+extra, max)}},
+			Tools:    agent.ToolsOff,
+		})
+		if err != nil {
+			return "", err
+		}
+		return normalizeTitle(resp.Text, TitleMaxChars), nil
+	}
+	title, err := run(TitleMaxChars, "")
+	if err != nil || title == "" {
+		if err == nil {
+			err = os.ErrInvalid
+		}
+		return SummaryResult{ID: key}, err
+	}
+	if len([]rune(normalizeTitle(title, 999))) > TitleMaxChars {
+		// 第一次给长了：加压再要一次更短的，仍按 12 字收口。
+		if shorter, serr := run(8, "\n（上一次给的标题太长了，请务必压缩到 8 个字以内）"); serr == nil && shorter != "" {
+			title = shorter
+		}
+	}
+	if err := ConsolidateTitle(sessionID, runID, title); err != nil {
+		return SummaryResult{ID: key, Title: title}, err
+	}
+	return SummaryResult{ID: key, Title: title}, nil
+}
+
+// SummarizeOptions 归纳一条会话标题的输入。
+type SummarizeOptions struct {
+	SessionID string
+	RunID     string
+	// Text 首问正文（空 = 自己从日志 / 登记表取）。
+	Text string
+	// Engine 归纳用哪个引擎（空 = llm，纯文本无工具）。
+	Engine string
+	// Force 已有覆盖时是否重新归纳（默认否：省一次 LLM 调用）。
+	Force   bool
+	Timeout time.Duration
+}
+
+// SummaryResult 归纳结果。
+type SummaryResult struct {
+	ID     string `json:"id"`
+	Title  string `json:"title,omitempty"`
+	Cached bool   `json:"cached,omitempty"`
+}