xonecas.io
60255
Zn

Zoea-Nova / files

Zoea-Nova / internal / store / memories.go

10.4 KB
1package store
2
3import (
4	"database/sql"
5	"fmt"
6	"strconv"
7	"time"
8
9	"github.com/rs/zerolog/log"
10)
11
12// MemoryRole represents the role in a conversation.
13type MemoryRole string
14
15const (
16	MemoryRoleSystem    MemoryRole = "system"
17	MemoryRoleUser      MemoryRole = "user"
18	MemoryRoleAssistant MemoryRole = "assistant"
19	MemoryRoleTool      MemoryRole = "tool"
20)
21
22// MemorySource indicates the origin of a message.
23type MemorySource string
24
25const (
26	MemorySourceDirect    MemorySource = "direct"    // Direct message to specific mysis
27	MemorySourceBroadcast MemorySource = "broadcast" // Broadcast message to all myses
28	MemorySourceSystem    MemorySource = "system"    // System prompts
29	MemorySourceLLM       MemorySource = "llm"       // LLM-generated responses
30	MemorySourceTool      MemorySource = "tool"      // Tool call results
31)
32
33// Memory represents a stored conversation message.
34type Memory struct {
35	ID        int64
36	MysisID   string
37	Role      MemoryRole
38	Source    MemorySource
39	SenderID  string
40	Content   string
41	Reasoning string
42	CreatedAt time.Time
43}
44
45// AddMemory adds a memory entry for a mysis.
46func (s *Store) AddMemory(mysisID string, role MemoryRole, source MemorySource, content string, reasoning string, senderID string) error {
47	now := time.Now().UTC()
48	_, err := s.db.Exec(`
49		INSERT INTO memories (mysis_id, role, source, sender_id, content, reasoning, created_at)
50		VALUES (?, ?, ?, ?, ?, ?, ?)
51	`, mysisID, role, source, senderID, content, reasoning, now)
52	return err
53}
54
55// GetMemories retrieves all memories for a mysis, ordered by creation time.
56func (s *Store) GetMemories(mysisID string) ([]*Memory, error) {
57	rows, err := s.db.Query(`
58		SELECT id, mysis_id, role, source, sender_id, content, reasoning, created_at
59		FROM memories
60		WHERE mysis_id = ?
61		ORDER BY created_at ASC
62	`, mysisID)
63	if err != nil {
64		return nil, fmt.Errorf("query memories: %w", err)
65	}
66	defer rows.Close()
67
68	var memories []*Memory
69	for rows.Next() {
70		var m Memory
71		var senderID sql.NullString
72		if err := rows.Scan(&m.ID, &m.MysisID, &m.Role, &m.Source, &senderID, &m.Content, &m.Reasoning, &m.CreatedAt); err != nil {
73			return nil, fmt.Errorf("scan memory: %w", err)
74		}
75		if senderID.Valid {
76			m.SenderID = senderID.String
77		}
78		memories = append(memories, &m)
79	}
80
81	return memories, rows.Err()
82}
83
84// GetSystemMemory retrieves the initial system prompt for a mysis.
85func (s *Store) GetSystemMemory(mysisID string) (*Memory, error) {
86	var m Memory
87	var senderID sql.NullString
88	err := s.db.QueryRow(`
89		SELECT id, mysis_id, role, source, sender_id, content, reasoning, created_at
90		FROM memories
91		WHERE mysis_id = ? AND role = 'system' AND source = 'system'
92		ORDER BY created_at ASC
93		LIMIT 1
94	`, mysisID).Scan(&m.ID, &m.MysisID, &m.Role, &m.Source, &senderID, &m.Content, &m.Reasoning, &m.CreatedAt)
95	if err != nil {
96		return nil, err
97	}
98	if senderID.Valid {
99		m.SenderID = senderID.String
100	}
101	return &m, nil
102}
103
104// DeleteSystemMemory deletes the system memory for a mysis
105func (s *Store) DeleteSystemMemory(mysisID string) error {
106	_, err := s.db.Exec(`DELETE FROM memories WHERE mysis_id = ? AND role = 'system'`, mysisID)
107	return err
108}
109
110// GetRecentMemories retrieves the most recent N memories for a mysis.
111func (s *Store) GetRecentMemories(mysisID string, limit int) ([]*Memory, error) {
112	rows, err := s.db.Query(`
113		SELECT id, mysis_id, role, source, sender_id, content, reasoning, created_at
114		FROM memories
115		WHERE mysis_id = ?
116		ORDER BY created_at DESC
117		LIMIT ?
118	`, mysisID, limit)
119	if err != nil {
120		return nil, fmt.Errorf("query recent memories: %w", err)
121	}
122	defer rows.Close()
123
124	var memories []*Memory
125	for rows.Next() {
126		var m Memory
127		var senderID sql.NullString
128		if err := rows.Scan(&m.ID, &m.MysisID, &m.Role, &m.Source, &senderID, &m.Content, &m.Reasoning, &m.CreatedAt); err != nil {
129			return nil, fmt.Errorf("scan memory: %w", err)
130		}
131		if senderID.Valid {
132			m.SenderID = senderID.String
133		}
134		memories = append(memories, &m)
135	}
136
137	// Reverse to get chronological order
138	for i, j := 0, len(memories)-1; i < j; i, j = i+1, j-1 {
139		memories[i], memories[j] = memories[j], memories[i]
140	}
141
142	return memories, rows.Err()
143}
144
145// DeleteMemories deletes all memories for a mysis.
146func (s *Store) DeleteMemories(mysisID string) error {
147	_, err := s.db.Exec(`DELETE FROM memories WHERE mysis_id = ?`, mysisID)
148	if err != nil {
149		return fmt.Errorf("delete memories: %w", err)
150	}
151	return nil
152}
153
154// CountMemories returns the number of memories for a mysis.
155func (s *Store) CountMemories(mysisID string) (int, error) {
156	var count int
157	err := s.db.QueryRow(`SELECT COUNT(*) FROM memories WHERE mysis_id = ?`, mysisID).Scan(&count)
158	return count, err
159}
160
161// BroadcastMessage represents a unique broadcast message across all myses.
162type BroadcastMessage struct {
163	SenderID  string
164	Content   string
165	CreatedAt time.Time
166}
167
168var broadcastTimeLayouts = []string{
169	"2006-01-02 15:04:05.999999999 -0700 MST",
170	time.RFC3339Nano,
171	"2006-01-02 15:04:05.999999999",
172	"2006-01-02 15:04:05",
173}
174
175func parseBroadcastTime(value string) (time.Time, error) {
176	for _, layout := range broadcastTimeLayouts {
177		if parsed, err := time.Parse(layout, value); err == nil {
178			return parsed, nil
179		}
180	}
181
182	if unixSeconds, err := strconv.ParseInt(value, 10, 64); err == nil {
183		return time.Unix(unixSeconds, 0).UTC(), nil
184	}
185
186	return time.Time{}, fmt.Errorf("parse broadcast time: %q", value)
187}
188
189// GetRecentBroadcasts retrieves the most recent N unique broadcast messages.
190// Since broadcasts are stored per-mysis, this groups by content to get unique messages.
191func (s *Store) GetRecentBroadcasts(limit int) ([]*BroadcastMessage, error) {
192	rows, err := s.db.Query(`
193		SELECT sender_id, content, MIN(created_at) as created_at
194		FROM memories
195		WHERE source = 'broadcast'
196		GROUP BY content, sender_id
197		ORDER BY created_at DESC
198		LIMIT ?
199	`, limit)
200	if err != nil {
201		return nil, fmt.Errorf("query broadcasts: %w", err)
202	}
203	defer rows.Close()
204
205	var messages []*BroadcastMessage
206	for rows.Next() {
207		var content, createdAtStr string
208		var senderID sql.NullString
209		if err := rows.Scan(&senderID, &content, &createdAtStr); err != nil {
210			return nil, fmt.Errorf("scan broadcast: %w", err)
211		}
212		createdAt, err := parseBroadcastTime(createdAtStr)
213		if err != nil {
214			log.Warn().
215				Err(err).
216				Str("created_at", createdAtStr).
217				Msg("failed to parse broadcast time")
218		}
219		message := &BroadcastMessage{
220			Content:   content,
221			CreatedAt: createdAt,
222		}
223		if senderID.Valid {
224			message.SenderID = senderID.String
225		}
226		messages = append(messages, message)
227	}
228
229	// Reverse to get chronological order (oldest first)
230	for i, j := 0, len(messages)-1; i < j; i, j = i+1, j-1 {
231		messages[i], messages[j] = messages[j], messages[i]
232	}
233
234	return messages, rows.Err()
235}
236
237// GetMostRecentBroadcast retrieves the most recent broadcast message for a specific mysis.
238// If no broadcast exists for this mysis, falls back to the most recent broadcast in the
239// entire system (global swarm mission). This ensures new myses inherit the current mission.
240// Returns nil only if no broadcasts exist anywhere in the system.
241func (s *Store) GetMostRecentBroadcast(mysisID string) (*Memory, error) {
242	var m Memory
243	var senderID sql.NullString
244
245	// First, try to find a broadcast for this specific mysis
246	err := s.db.QueryRow(`
247		SELECT id, mysis_id, role, source, sender_id, content, reasoning, created_at
248		FROM memories
249		WHERE mysis_id = ? AND source = 'broadcast'
250		ORDER BY created_at DESC
251		LIMIT 1
252	`, mysisID).Scan(&m.ID, &m.MysisID, &m.Role, &m.Source, &senderID, &m.Content, &m.Reasoning, &m.CreatedAt)
253
254	if err == nil {
255		// Found a broadcast for this mysis
256		if senderID.Valid {
257			m.SenderID = senderID.String
258		}
259		return &m, nil
260	}
261
262	if err != sql.ErrNoRows {
263		// Real database error
264		return nil, fmt.Errorf("query mysis-specific broadcast: %w", err)
265	}
266
267	// No broadcast for this mysis - fall back to most recent global broadcast
268	// This handles new myses created after a broadcast was sent
269	err = s.db.QueryRow(`
270		SELECT id, mysis_id, role, source, sender_id, content, reasoning, created_at
271		FROM memories
272		WHERE source = 'broadcast'
273		ORDER BY created_at DESC
274		LIMIT 1
275	`).Scan(&m.ID, &m.MysisID, &m.Role, &m.Source, &senderID, &m.Content, &m.Reasoning, &m.CreatedAt)
276
277	if err == sql.ErrNoRows {
278		// No broadcasts anywhere in the system
279		return nil, nil
280	}
281	if err != nil {
282		return nil, fmt.Errorf("query global broadcast: %w", err)
283	}
284	if senderID.Valid {
285		m.SenderID = senderID.String
286	}
287
288	// Return the global broadcast (with original mysis_id preserved for tracking)
289	return &m, nil
290}
291
292// SearchMemories searches memories for a mysis by content text.
293// Returns memories where content contains the query string (case-sensitive).
294func (s *Store) SearchMemories(mysisID, query string, limit int) ([]*Memory, error) {
295	rows, err := s.db.Query(`
296		SELECT id, mysis_id, role, source, sender_id, content, reasoning, created_at
297		FROM memories
298		WHERE mysis_id = ? AND content LIKE '%' || ? || '%'
299		ORDER BY created_at DESC
300		LIMIT ?
301	`, mysisID, query, limit)
302	if err != nil {
303		return nil, fmt.Errorf("search memories: %w", err)
304	}
305	defer rows.Close()
306
307	var memories []*Memory
308	for rows.Next() {
309		var m Memory
310		var senderID sql.NullString
311		if err := rows.Scan(&m.ID, &m.MysisID, &m.Role, &m.Source, &senderID, &m.Content, &m.Reasoning, &m.CreatedAt); err != nil {
312			return nil, fmt.Errorf("scan memory: %w", err)
313		}
314		if senderID.Valid {
315			m.SenderID = senderID.String
316		}
317		memories = append(memories, &m)
318	}
319
320	// Reverse to get chronological order (oldest first)
321	for i, j := 0, len(memories)-1; i < j; i, j = i+1, j-1 {
322		memories[i], memories[j] = memories[j], memories[i]
323	}
324
325	return memories, rows.Err()
326}
327
328func (s *Store) SearchReasoning(mysisID, query string, limit int) ([]*Memory, error) {
329	rows, err := s.db.Query(`
330		SELECT id, mysis_id, role, source, sender_id, content, reasoning, created_at
331		FROM memories
332		WHERE mysis_id = ? AND reasoning LIKE '%' || ? || '%'
333		ORDER BY created_at DESC
334		LIMIT ?
335	`, mysisID, query, limit)
336	if err != nil {
337		return nil, fmt.Errorf("search reasoning: %w", err)
338	}
339	defer rows.Close()
340
341	var memories []*Memory
342	for rows.Next() {
343		var m Memory
344		var senderID sql.NullString
345		if err := rows.Scan(&m.ID, &m.MysisID, &m.Role, &m.Source, &senderID, &m.Content, &m.Reasoning, &m.CreatedAt); err != nil {
346			return nil, fmt.Errorf("scan memory: %w", err)
347		}
348		if senderID.Valid {
349			m.SenderID = senderID.String
350		}
351		memories = append(memories, &m)
352	}
353
354	for i, j := 0, len(memories)-1; i < j; i, j = i+1, j-1 {
355		memories[i], memories[j] = memories[j], memories[i]
356	}
357
358	return memories, rows.Err()
359}