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}