321 lines
7.3 KiB
Go
321 lines
7.3 KiB
Go
package services
|
|
|
|
import (
|
|
"encoding/json"
|
|
"os"
|
|
"path/filepath"
|
|
"regexp"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
|
|
"sproutclaw-web/internal/db"
|
|
"sproutclaw-web/internal/models"
|
|
)
|
|
|
|
// sessionLine is one parsed line of a session JSONL file.
|
|
type sessionLine struct {
|
|
Type string `json:"type"`
|
|
ID string `json:"id"`
|
|
Timestamp string `json:"timestamp"`
|
|
Name string `json:"name"`
|
|
Message json.RawMessage `json:"message"`
|
|
}
|
|
|
|
type sessionMessage struct {
|
|
Role string `json:"role"`
|
|
Content json.RawMessage `json:"content"`
|
|
}
|
|
|
|
var (
|
|
reHex = regexp.MustCompile(`^[0-9a-fA-F]{8,}$`)
|
|
reDigits = regexp.MustCompile(`^[0-9]{10,}$`)
|
|
reWS = regexp.MustCompile(`\s+`)
|
|
reFirstSentence = regexp.MustCompile(`^(.+?[。！？.!?])(\s|$)`)
|
|
)
|
|
|
|
// listSessionFiles recursively collects every *.jsonl under sessionsDir.
|
|
// pi stores sessions in cwd-encoded subdirectories, e.g.
|
|
// sessions/--D--SmyProjects-AI-sproutclaw--/<id>.jsonl
|
|
func listSessionFiles(sessionsDir string) []string {
|
|
var files []string
|
|
_ = filepath.WalkDir(sessionsDir, func(path string, d os.DirEntry, err error) error {
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
if !d.IsDir() && strings.HasSuffix(d.Name(), ".jsonl") {
|
|
files = append(files, path)
|
|
}
|
|
return nil
|
|
})
|
|
// newest first by path (ids are time-sortable); final sort happens later
|
|
sort.Sort(sort.Reverse(sort.StringSlice(files)))
|
|
return files
|
|
}
|
|
|
|
func isMachineSessionLabel(text, headerID string) bool {
|
|
t := strings.TrimSpace(text)
|
|
if t == "" {
|
|
return true
|
|
}
|
|
if headerID != "" && t == headerID {
|
|
return true
|
|
}
|
|
if reHex.MatchString(t) || reDigits.MatchString(t) {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
func titleFromFirstUserMessage(text string) string {
|
|
const maxChars = 56
|
|
cleaned := strings.TrimSpace(reWS.ReplaceAllString(text, " "))
|
|
if cleaned == "" {
|
|
return ""
|
|
}
|
|
candidate := cleaned
|
|
if m := reFirstSentence.FindStringSubmatch(cleaned); m != nil && m[1] != "" {
|
|
candidate = strings.TrimSpace(m[1])
|
|
}
|
|
runes := []rune(candidate)
|
|
if len(runes) > maxChars {
|
|
candidate = strings.TrimRight(string(runes[:maxChars]), " ") + "…"
|
|
}
|
|
return candidate
|
|
}
|
|
|
|
func extractPreview(msg sessionMessage) string {
|
|
if len(msg.Content) == 0 {
|
|
return ""
|
|
}
|
|
// content may be a string
|
|
var s string
|
|
if json.Unmarshal(msg.Content, &s) == nil {
|
|
return truncate(s, 200)
|
|
}
|
|
// or an array of blocks
|
|
var blocks []map[string]any
|
|
if json.Unmarshal(msg.Content, &blocks) == nil {
|
|
var sb strings.Builder
|
|
imageCount := 0
|
|
for _, b := range blocks {
|
|
switch b["type"] {
|
|
case "text":
|
|
if t, ok := b["text"].(string); ok {
|
|
sb.WriteString(t)
|
|
}
|
|
case "image":
|
|
imageCount++
|
|
}
|
|
}
|
|
if txt := sb.String(); txt != "" {
|
|
return truncate(txt, 200)
|
|
}
|
|
if imageCount > 0 {
|
|
return "[" + itoa(imageCount) + " 张图片]"
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// readSessionSummary parses one session file into a summary (nil if not a session).
|
|
func readSessionSummary(path string) (models.SessionSummary, bool) {
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return models.SessionSummary{}, false
|
|
}
|
|
lines := strings.Split(strings.TrimSpace(string(data)), "\n")
|
|
if len(lines) == 0 {
|
|
return models.SessionSummary{}, false
|
|
}
|
|
|
|
var header sessionLine
|
|
if json.Unmarshal([]byte(lines[0]), &header) != nil || header.Type != "session" {
|
|
return models.SessionSummary{}, false
|
|
}
|
|
|
|
info, _ := os.Stat(path)
|
|
modified := ""
|
|
if info != nil {
|
|
modified = info.ModTime().UTC().Format(time.RFC3339)
|
|
}
|
|
|
|
nameFromInfo := ""
|
|
messageCount := 0
|
|
firstMessage := ""
|
|
|
|
for _, line := range lines {
|
|
if strings.TrimSpace(line) == "" {
|
|
continue
|
|
}
|
|
var entry sessionLine
|
|
if json.Unmarshal([]byte(line), &entry) != nil {
|
|
continue
|
|
}
|
|
switch entry.Type {
|
|
case "session_info":
|
|
if entry.Name != "" {
|
|
n := strings.TrimSpace(entry.Name)
|
|
if n != "" && !isMachineSessionLabel(n, header.ID) {
|
|
nameFromInfo = n
|
|
}
|
|
}
|
|
case "message":
|
|
messageCount++
|
|
if firstMessage == "" && len(entry.Message) > 0 {
|
|
var m sessionMessage
|
|
if json.Unmarshal(entry.Message, &m) == nil && m.Role == "user" {
|
|
firstMessage = extractPreview(m)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
name := nameFromInfo
|
|
if name == "" || isMachineSessionLabel(name, header.ID) {
|
|
name = titleFromFirstUserMessage(firstMessage)
|
|
}
|
|
|
|
preview := firstMessage
|
|
if preview == "" {
|
|
preview = "(空)"
|
|
}
|
|
|
|
return models.SessionSummary{
|
|
Path: path,
|
|
Name: name,
|
|
Created: header.Timestamp,
|
|
Modified: modified,
|
|
MessageCount: messageCount,
|
|
FirstMessage: preview,
|
|
}, true
|
|
}
|
|
|
|
// BuildSessionList recursively reads all sessions and assembles the response.
|
|
func BuildSessionList(sessionsDir string, database *db.DB) ([]models.SessionSummary, error) {
|
|
if _, err := os.Stat(sessionsDir); err != nil {
|
|
return nil, nil
|
|
}
|
|
|
|
pinned, _ := database.GetPinnedSessions()
|
|
pinnedOrder := map[string]int{}
|
|
for i, p := range pinned {
|
|
pinnedOrder[filepath.Clean(p)] = i
|
|
}
|
|
|
|
var summaries []models.SessionSummary
|
|
for _, f := range listSessionFiles(sessionsDir) {
|
|
sum, ok := readSessionSummary(f)
|
|
if !ok {
|
|
continue
|
|
}
|
|
_, sum.Pinned = pinnedOrder[filepath.Clean(f)]
|
|
summaries = append(summaries, sum)
|
|
}
|
|
|
|
sort.SliceStable(summaries, func(i, j int) bool {
|
|
ci, iPinned := pinnedOrder[filepath.Clean(summaries[i].Path)]
|
|
cj, jPinned := pinnedOrder[filepath.Clean(summaries[j].Path)]
|
|
if iPinned && jPinned {
|
|
return ci < cj
|
|
}
|
|
if iPinned != jPinned {
|
|
return iPinned
|
|
}
|
|
return sessionSortKey(summaries[i]) > sessionSortKey(summaries[j])
|
|
})
|
|
return summaries, nil
|
|
}
|
|
|
|
func sessionSortKey(s models.SessionSummary) string {
|
|
if s.Modified != "" {
|
|
return s.Modified
|
|
}
|
|
return s.Created
|
|
}
|
|
|
|
// ReadSessionSummaryByPath returns a single session's summary (exported).
|
|
func ReadSessionSummaryByPath(path string) (models.SessionSummary, error) {
|
|
sum, ok := readSessionSummary(path)
|
|
if !ok {
|
|
return models.SessionSummary{Path: path}, nil
|
|
}
|
|
return sum, nil
|
|
}
|
|
|
|
// ReadSessionMessages returns the `message` payload of each message line.
|
|
func ReadSessionMessages(path string) ([]json.RawMessage, error) {
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var out []json.RawMessage
|
|
for _, line := range strings.Split(strings.TrimSpace(string(data)), "\n") {
|
|
if strings.TrimSpace(line) == "" {
|
|
continue
|
|
}
|
|
var entry sessionLine
|
|
if json.Unmarshal([]byte(line), &entry) != nil {
|
|
continue
|
|
}
|
|
if entry.Type == "message" && len(entry.Message) > 0 {
|
|
out = append(out, entry.Message)
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// AppendSessionName appends a session_info rename record to the JSONL file.
|
|
func AppendSessionName(path, name string) error {
|
|
trimmed := strings.TrimSpace(name)
|
|
if trimmed == "" {
|
|
return os.ErrInvalid
|
|
}
|
|
f, err := os.OpenFile(path, os.O_APPEND|os.O_WRONLY, 0o644)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer f.Close()
|
|
record := map[string]any{
|
|
"type": "session_info",
|
|
"timestamp": time.Now().UTC().Format(time.RFC3339),
|
|
"name": trimmed,
|
|
}
|
|
b, err := json.Marshal(record)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = f.Write(append([]byte("\n"), b...))
|
|
return err
|
|
}
|
|
|
|
func truncate(s string, n int) string {
|
|
r := []rune(s)
|
|
if len(r) <= n {
|
|
return s
|
|
}
|
|
return string(r[:n])
|
|
}
|
|
|
|
func itoa(n int) string {
|
|
if n == 0 {
|
|
return "0"
|
|
}
|
|
neg := n < 0
|
|
if neg {
|
|
n = -n
|
|
}
|
|
var b [20]byte
|
|
i := len(b)
|
|
for n > 0 {
|
|
i--
|
|
b[i] = byte('0' + n%10)
|
|
n /= 10
|
|
}
|
|
if neg {
|
|
i--
|
|
b[i] = '-'
|
|
}
|
|
return string(b[i:])
|
|
}
|