wehub-resource-sync
95 lines
2.8 KiB
Go
95 lines
2.8 KiB
Go
package agent
|
|
|
|
import (
|
|
"bytes"
|
|
"os"
|
|
"time"
|
|
|
|
"reasonix/internal/provider"
|
|
"reasonix/internal/store"
|
|
)
|
|
|
|
// SessionsShareContent reports whether two saved sessions decode to the same
|
|
// transcript. It replaces byte-comparing the .jsonl checkpoints, which stopped
|
|
// implying transcript equality once the event log became authoritative: two
|
|
// identical checkpoints can hide diverged event logs.
|
|
func SessionsShareContent(pathA, pathB string) (bool, error) {
|
|
msgsA, _, _, err := loadSessionMessages(pathA)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
msgsB, _, _, err := loadSessionMessages(pathB)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
digestA, err := digestSessionMessages(msgsA)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
digestB, err := digestSessionMessages(msgsB)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
return bytes.Equal(digestA[:], digestB[:]), nil
|
|
}
|
|
|
|
// SessionUserMessage is one user-role message with the best-known wall-clock
|
|
// time. Messages restored from a replace event (compaction, rewind) lose their
|
|
// per-turn times and report zero; callers apply their own fallback.
|
|
type SessionUserMessage struct {
|
|
Text string
|
|
At time.Time
|
|
}
|
|
|
|
// LoadSessionUserMessages returns the session's user-role messages in
|
|
// transcript order, event-log aware. Direct .jsonl decoding misses everything
|
|
// after the first save once an event log exists, so surfaces like prompt
|
|
// history must use this instead.
|
|
func LoadSessionUserMessages(path string) ([]SessionUserMessage, error) {
|
|
if probe, err := probeSessionEventLog(path); err == nil && probe.native && probe.size > 0 {
|
|
replay, err := replaySessionEventLog(store.SessionEventLog(path))
|
|
if err == nil && replay.records > 0 {
|
|
out := make([]SessionUserMessage, 0, len(replay.msgs))
|
|
for i, m := range replay.msgs {
|
|
if m.Role != provider.RoleUser {
|
|
continue
|
|
}
|
|
at := time.Time{}
|
|
if i < len(replay.times) {
|
|
at = replay.times[i]
|
|
}
|
|
out = append(out, SessionUserMessage{Text: m.Content, At: at})
|
|
}
|
|
return out, nil
|
|
}
|
|
}
|
|
msgs, err := loadSessionMessagesFromJSONL(path)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out := make([]SessionUserMessage, 0, len(msgs))
|
|
for _, m := range msgs {
|
|
if m.Role != provider.RoleUser {
|
|
continue
|
|
}
|
|
out = append(out, SessionUserMessage{Text: m.Content})
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// SessionContentModTime returns when the session transcript last changed on
|
|
// disk: the newer of the .jsonl checkpoint and the event log. The checkpoint
|
|
// alone goes stale between checkpoints, so recency ordering must use this.
|
|
func SessionContentModTime(path string) time.Time {
|
|
var mod time.Time
|
|
if info, err := os.Stat(path); err == nil && !info.IsDir() {
|
|
mod = info.ModTime()
|
|
}
|
|
if logPath := store.SessionEventLog(path); logPath != "" {
|
|
if info, err := os.Stat(logPath); err == nil && !info.IsDir() && info.ModTime().After(mod) {
|
|
mod = info.ModTime()
|
|
}
|
|
}
|
|
return mod
|
|
}
|