xonecas.io
60255
Zn

Zoea-Nova / commit cc436f2

feat(db): add sender_id to memories for broadcast tracking

Schema v7 → v8. Breaking change requires fresh database.

Changes:
- Add sender_id column to memories table
- Update Memory and BroadcastMessage structs with SenderID field
- Update all query methods to retrieve sender_id consistently
- Change AddMemory signature to accept senderID parameter
- Update all test calls to AddMemory with empty sender_id

Migration: run 'make db-reset-accounts' to upgrade

xonecas2026-02-05 cc436f2ac5184d17c1e578bdcea8e4577207cfa7 parent f6797a5

5 files changed

internal/store/memories.go+59−40
@@ -1,6 +1,7 @@
11 package store
22
33 import (
4+ "database/sql"
45 "fmt"
56 "time"
67 )
@@ -32,39 +33,26 @@ type Memory struct {
3233 MysisID string
3334 Role MemoryRole
3435 Source MemorySource
36+ SenderID string
3537 Content string
3638 Reasoning string
3739 CreatedAt time.Time
3840 }
3941
4042 // AddMemory adds a memory entry for a mysis.
41-func (s *Store) AddMemory(mysisID string, role MemoryRole, source MemorySource, content string, reasoning string) (*Memory, error) {
43+func (s *Store) AddMemory(mysisID string, role MemoryRole, source MemorySource, content string, reasoning string, senderID string) error {
4244 now := time.Now().UTC()
43-
44- result, err := s.db.Exec(`
45- INSERT INTO memories (mysis_id, role, source, content, reasoning, created_at)
46- VALUES (?, ?, ?, ?, ?, ?)
47- `, mysisID, role, source, content, reasoning, now)
48- if err != nil {
49- return nil, fmt.Errorf("insert memory: %w", err)
50- }
51-
52- id, _ := result.LastInsertId()
53- return &Memory{
54- ID: id,
55- MysisID: mysisID,
56- Role: role,
57- Source: source,
58- Content: content,
59- Reasoning: reasoning,
60- CreatedAt: now,
61- }, nil
45+ _, err := s.db.Exec(`
46+ INSERT INTO memories (mysis_id, role, source, sender_id, content, reasoning, created_at)
47+ VALUES (?, ?, ?, ?, ?, ?, ?)
48+ `, mysisID, role, source, senderID, content, reasoning, now)
49+ return err
6250 }
6351
6452 // GetMemories retrieves all memories for a mysis, ordered by creation time.
6553 func (s *Store) GetMemories(mysisID string) ([]*Memory, error) {
6654 rows, err := s.db.Query(`
67- SELECT id, mysis_id, role, source, content, reasoning, created_at
55+ SELECT id, mysis_id, role, source, sender_id, content, reasoning, created_at
6856 FROM memories
6957 WHERE mysis_id = ?
7058 ORDER BY created_at ASC
@@ -77,9 +65,13 @@ func (s *Store) GetMemories(mysisID string) ([]*Memory, error) {
7765 var memories []*Memory
7866 for rows.Next() {
7967 var m Memory
80- if err := rows.Scan(&m.ID, &m.MysisID, &m.Role, &m.Source, &m.Content, &m.Reasoning, &m.CreatedAt); err != nil {
68+ var senderID sql.NullString
69+ if err := rows.Scan(&m.ID, &m.MysisID, &m.Role, &m.Source, &senderID, &m.Content, &m.Reasoning, &m.CreatedAt); err != nil {
8170 return nil, fmt.Errorf("scan memory: %w", err)
8271 }
72+ if senderID.Valid {
73+ m.SenderID = senderID.String
74+ }
8375 memories = append(memories, &m)
8476 }
8577
@@ -89,23 +81,27 @@ func (s *Store) GetMemories(mysisID string) ([]*Memory, error) {
8981 // GetSystemMemory retrieves the initial system prompt for a mysis.
9082 func (s *Store) GetSystemMemory(mysisID string) (*Memory, error) {
9183 var m Memory
84+ var senderID sql.NullString
9285 err := s.db.QueryRow(`
93- SELECT id, mysis_id, role, source, content, reasoning, created_at
86+ SELECT id, mysis_id, role, source, sender_id, content, reasoning, created_at
9487 FROM memories
9588 WHERE mysis_id = ? AND role = 'system' AND source = 'system'
9689 ORDER BY created_at ASC
9790 LIMIT 1
98- `, mysisID).Scan(&m.ID, &m.MysisID, &m.Role, &m.Source, &m.Content, &m.Reasoning, &m.CreatedAt)
91+ `, mysisID).Scan(&m.ID, &m.MysisID, &m.Role, &m.Source, &senderID, &m.Content, &m.Reasoning, &m.CreatedAt)
9992 if err != nil {
10093 return nil, err
10194 }
95+ if senderID.Valid {
96+ m.SenderID = senderID.String
97+ }
10298 return &m, nil
10399 }
104100
105101 // GetRecentMemories retrieves the most recent N memories for a mysis.
106102 func (s *Store) GetRecentMemories(mysisID string, limit int) ([]*Memory, error) {
107103 rows, err := s.db.Query(`
108- SELECT id, mysis_id, role, source, content, reasoning, created_at
104+ SELECT id, mysis_id, role, source, sender_id, content, reasoning, created_at
109105 FROM memories
110106 WHERE mysis_id = ?
111107 ORDER BY created_at DESC
@@ -119,9 +115,13 @@ func (s *Store) GetRecentMemories(mysisID string, limit int) ([]*Memory, error)
119115 var memories []*Memory
120116 for rows.Next() {
121117 var m Memory
122- if err := rows.Scan(&m.ID, &m.MysisID, &m.Role, &m.Source, &m.Content, &m.Reasoning, &m.CreatedAt); err != nil {
118+ var senderID sql.NullString
119+ if err := rows.Scan(&m.ID, &m.MysisID, &m.Role, &m.Source, &senderID, &m.Content, &m.Reasoning, &m.CreatedAt); err != nil {
123120 return nil, fmt.Errorf("scan memory: %w", err)
124121 }
122+ if senderID.Valid {
123+ m.SenderID = senderID.String
124+ }
125125 memories = append(memories, &m)
126126 }
127127
@@ -151,6 +151,7 @@ func (s *Store) CountMemories(mysisID string) (int, error) {
151151
152152 // BroadcastMessage represents a unique broadcast message across all myses.
153153 type BroadcastMessage struct {
154+ SenderID string
154155 Content string
155156 CreatedAt time.Time
156157 }
@@ -159,10 +160,10 @@ type BroadcastMessage struct {
159160 // Since broadcasts are stored per-mysis, this groups by content to get unique messages.
160161 func (s *Store) GetRecentBroadcasts(limit int) ([]*BroadcastMessage, error) {
161162 rows, err := s.db.Query(`
162- SELECT content, MIN(created_at) as created_at
163+ SELECT sender_id, content, MIN(created_at) as created_at
163164 FROM memories
164165 WHERE source = 'broadcast'
165- GROUP BY content
166+ GROUP BY content, sender_id
166167 ORDER BY created_at DESC
167168 LIMIT ?
168169 `, limit)
@@ -174,7 +175,8 @@ func (s *Store) GetRecentBroadcasts(limit int) ([]*BroadcastMessage, error) {
174175 var messages []*BroadcastMessage
175176 for rows.Next() {
176177 var content, createdAtStr string
177- if err := rows.Scan(&content, &createdAtStr); err != nil {
178+ var senderID sql.NullString
179+ if err := rows.Scan(&senderID, &content, &createdAtStr); err != nil {
178180 return nil, fmt.Errorf("scan broadcast: %w", err)
179181 }
180182 // Parse the time string (SQLite returns aggregated times as strings)
@@ -183,10 +185,14 @@ func (s *Store) GetRecentBroadcasts(limit int) ([]*BroadcastMessage, error) {
183185 // Try alternate format
184186 createdAt, _ = time.Parse(time.RFC3339Nano, createdAtStr)
185187 }
186- messages = append(messages, &BroadcastMessage{
188+ message := &BroadcastMessage{
187189 Content: content,
188190 CreatedAt: createdAt,
189- })
191+ }
192+ if senderID.Valid {
193+ message.SenderID = senderID.String
194+ }
195+ messages = append(messages, message)
190196 }
191197
192198 // Reverse to get chronological order (oldest first)
@@ -201,7 +207,7 @@ func (s *Store) GetRecentBroadcasts(limit int) ([]*BroadcastMessage, error) {
201207 // Returns memories where content contains the query string (case-sensitive).
202208 func (s *Store) SearchMemories(mysisID, query string, limit int) ([]*Memory, error) {
203209 rows, err := s.db.Query(`
204- SELECT id, mysis_id, role, source, content, reasoning, created_at
210+ SELECT id, mysis_id, role, source, sender_id, content, reasoning, created_at
205211 FROM memories
206212 WHERE mysis_id = ? AND content LIKE '%' || ? || '%'
207213 ORDER BY created_at DESC
@@ -215,9 +221,13 @@ func (s *Store) SearchMemories(mysisID, query string, limit int) ([]*Memory, err
215221 var memories []*Memory
216222 for rows.Next() {
217223 var m Memory
218- if err := rows.Scan(&m.ID, &m.MysisID, &m.Role, &m.Source, &m.Content, &m.Reasoning, &m.CreatedAt); err != nil {
224+ var senderID sql.NullString
225+ if err := rows.Scan(&m.ID, &m.MysisID, &m.Role, &m.Source, &senderID, &m.Content, &m.Reasoning, &m.CreatedAt); err != nil {
219226 return nil, fmt.Errorf("scan memory: %w", err)
220227 }
228+ if senderID.Valid {
229+ m.SenderID = senderID.String
230+ }
221231 memories = append(memories, &m)
222232 }
223233
@@ -231,7 +241,7 @@ func (s *Store) SearchMemories(mysisID, query string, limit int) ([]*Memory, err
231241
232242 func (s *Store) SearchReasoning(mysisID, query string, limit int) ([]*Memory, error) {
233243 rows, err := s.db.Query(`
234- SELECT id, mysis_id, role, source, content, reasoning, created_at
244+ SELECT id, mysis_id, role, source, sender_id, content, reasoning, created_at
235245 FROM memories
236246 WHERE mysis_id = ? AND reasoning LIKE '%' || ? || '%'
237247 ORDER BY created_at DESC
@@ -245,9 +255,13 @@ func (s *Store) SearchReasoning(mysisID, query string, limit int) ([]*Memory, er
245255 var memories []*Memory
246256 for rows.Next() {
247257 var m Memory
248- if err := rows.Scan(&m.ID, &m.MysisID, &m.Role, &m.Source, &m.Content, &m.Reasoning, &m.CreatedAt); err != nil {
258+ var senderID sql.NullString
259+ if err := rows.Scan(&m.ID, &m.MysisID, &m.Role, &m.Source, &senderID, &m.Content, &m.Reasoning, &m.CreatedAt); err != nil {
249260 return nil, fmt.Errorf("scan memory: %w", err)
250261 }
262+ if senderID.Valid {
263+ m.SenderID = senderID.String
264+ }
251265 memories = append(memories, &m)
252266 }
253267
@@ -262,10 +276,10 @@ func (s *Store) SearchReasoning(mysisID, query string, limit int) ([]*Memory, er
262276 // Returns broadcasts where content contains the query string (case-sensitive).
263277 func (s *Store) SearchBroadcasts(query string, limit int) ([]*BroadcastMessage, error) {
264278 rows, err := s.db.Query(`
265- SELECT content, MAX(created_at) as created_at
279+ SELECT sender_id, content, MAX(created_at) as created_at
266280 FROM memories
267281 WHERE source = 'broadcast' AND content LIKE '%' || ? || '%'
268- GROUP BY content
282+ GROUP BY content, sender_id
269283 ORDER BY created_at DESC
270284 LIMIT ?
271285 `, query, limit)
@@ -277,17 +291,22 @@ func (s *Store) SearchBroadcasts(query string, limit int) ([]*BroadcastMessage,
277291 var messages []*BroadcastMessage
278292 for rows.Next() {
279293 var content, createdAtStr string
280- if err := rows.Scan(&content, &createdAtStr); err != nil {
294+ var senderID sql.NullString
295+ if err := rows.Scan(&senderID, &content, &createdAtStr); err != nil {
281296 return nil, fmt.Errorf("scan broadcast: %w", err)
282297 }
283298 createdAt, _ := time.Parse("2006-01-02 15:04:05.999999999 -0700 MST", createdAtStr)
284299 if createdAt.IsZero() {
285300 createdAt, _ = time.Parse(time.RFC3339Nano, createdAtStr)
286301 }
287- messages = append(messages, &BroadcastMessage{
302+ message := &BroadcastMessage{
288303 Content: content,
289304 CreatedAt: createdAt,
290- })
305+ }
306+ if senderID.Valid {
307+ message.SenderID = senderID.String
308+ }
309+ messages = append(messages, message)
291310 }
292311
293312 // Reverse to get chronological order (oldest first)
internal/store/memories_test.go+41−15
@@ -30,10 +30,10 @@ func TestGetSystemMemory(t *testing.T) {
3030
3131 // Add system memory
3232 expected := "You are a test."
33- s.AddMemory(mysis.ID, MemoryRoleSystem, MemorySourceSystem, expected, "")
33+ s.AddMemory(mysis.ID, MemoryRoleSystem, MemorySourceSystem, expected, "", "")
3434
3535 // Add other memories
36- s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceDirect, "hello", "")
36+ s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceDirect, "hello", "", "")
3737
3838 system, err := s.GetSystemMemory(mysis.ID)
3939 if err != nil {
@@ -50,9 +50,9 @@ func TestSearchMemories(t *testing.T) {
5050
5151 mysis, _ := s.CreateMysis("test", "mock", "model", 0.7)
5252
53- s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceDirect, "I like apples", "")
54- s.AddMemory(mysis.ID, MemoryRoleAssistant, MemorySourceLLM, "Apples are great", "")
55- s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceDirect, "What about oranges?", "")
53+ s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceDirect, "I like apples", "", "")
54+ s.AddMemory(mysis.ID, MemoryRoleAssistant, MemorySourceLLM, "Apples are great", "", "")
55+ s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceDirect, "What about oranges?", "", "")
5656
5757 // Search for "apples"
5858 results, err := s.SearchMemories(mysis.ID, "apples", 10)
@@ -80,9 +80,9 @@ func TestSearchBroadcasts(t *testing.T) {
8080 mysis1, _ := s.CreateMysis("mysis1", "mock", "model", 0.7)
8181 mysis2, _ := s.CreateMysis("mysis2", "mock", "model", 0.7)
8282
83- s.AddMemory(mysis1.ID, MemoryRoleUser, MemorySourceBroadcast, "Broadcast message 1", "")
84- s.AddMemory(mysis2.ID, MemoryRoleUser, MemorySourceBroadcast, "Broadcast message 2", "")
85- s.AddMemory(mysis1.ID, MemoryRoleUser, MemorySourceDirect, "Direct message", "")
83+ s.AddMemory(mysis1.ID, MemoryRoleUser, MemorySourceBroadcast, "Broadcast message 1", "", "")
84+ s.AddMemory(mysis2.ID, MemoryRoleUser, MemorySourceBroadcast, "Broadcast message 2", "", "")
85+ s.AddMemory(mysis1.ID, MemoryRoleUser, MemorySourceDirect, "Direct message", "", "")
8686
8787 // Search for "Broadcast"
8888 results, err := s.SearchBroadcasts("Broadcast", 10)
@@ -111,9 +111,9 @@ func TestSearchReasoning(t *testing.T) {
111111
112112 mysis, _ := s.CreateMysis("test", "mock", "model", 0.7)
113113
114- s.AddMemory(mysis.ID, MemoryRoleAssistant, MemorySourceLLM, "", "I am thinking about mining")
115- s.AddMemory(mysis.ID, MemoryRoleAssistant, MemorySourceLLM, "", "Trading strategy")
116- s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceDirect, "hello", "")
114+ s.AddMemory(mysis.ID, MemoryRoleAssistant, MemorySourceLLM, "", "I am thinking about mining", "")
115+ s.AddMemory(mysis.ID, MemoryRoleAssistant, MemorySourceLLM, "", "Trading strategy", "")
116+ s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceDirect, "hello", "", "")
117117
118118 results, err := s.SearchReasoning(mysis.ID, "mining", 10)
119119 if err != nil {
@@ -130,10 +130,10 @@ func TestGetRecentBroadcasts(t *testing.T) {
130130
131131 mysis, _ := s.CreateMysis("test", "mock", "model", 0.7)
132132
133- s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceBroadcast, "B1", "")
134- s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceBroadcast, "B2", "")
135- s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceBroadcast, "B3", "")
136- s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceDirect, "D1", "")
133+ s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceBroadcast, "B1", "", "")
134+ s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceBroadcast, "B2", "", "")
135+ s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceBroadcast, "B3", "", "")
136+ s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceDirect, "D1", "", "")
137137
138138 results, err := s.GetRecentBroadcasts(2)
139139 if err != nil {
@@ -150,3 +150,29 @@ func TestGetRecentBroadcasts(t *testing.T) {
150150 t.Errorf("expected B3, got %s", results[1].Content)
151151 }
152152 }
153+
154+func TestMemoryWithSenderID(t *testing.T) {
155+ s, cleanup := setupMemoriesTest(t)
156+ defer cleanup()
157+
158+ mysis, _ := s.CreateMysis("test", "mock", "model", 0.7)
159+ senderID := "sender-mysis"
160+
161+ err := s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceBroadcast, "test broadcast", "", senderID)
162+ if err != nil {
163+ t.Fatalf("AddMemory failed: %v", err)
164+ }
165+
166+ memories, err := s.GetRecentMemories(mysis.ID, 10)
167+ if err != nil {
168+ t.Fatalf("GetRecentMemories failed: %v", err)
169+ }
170+
171+ if len(memories) != 1 {
172+ t.Fatalf("expected 1 memory, got %d", len(memories))
173+ }
174+
175+ if memories[0].SenderID != senderID {
176+ t.Errorf("expected sender_id %q, got %q", senderID, memories[0].SenderID)
177+ }
178+}
internal/store/schema.sql+5−1
@@ -4,7 +4,10 @@ CREATE TABLE IF NOT EXISTS schema_version (
44 version INTEGER PRIMARY KEY
55 );
66
7-INSERT OR REPLACE INTO schema_version (version) VALUES (7);
7+-- Schema v7 → v8 Migration:
8+-- Added sender_id column to memories table for broadcast tracking.
9+-- BREAKING CHANGE: Requires fresh database (make db-reset-accounts)
10+INSERT OR REPLACE INTO schema_version (version) VALUES (8);
811
912 CREATE TABLE IF NOT EXISTS myses (
1013 id TEXT PRIMARY KEY,
@@ -22,6 +25,7 @@ CREATE TABLE IF NOT EXISTS memories (
2225 mysis_id TEXT NOT NULL,
2326 role TEXT NOT NULL,
2427 source TEXT NOT NULL DEFAULT 'direct',
28+ sender_id TEXT,
2529 content TEXT NOT NULL,
2630 reasoning TEXT,
2731 created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
internal/store/store.go+1−1
@@ -15,7 +15,7 @@ import (
1515 //go:embed schema.sql
1616 var schema string
1717
18-const currentSchemaVersion = 7
18+const currentSchemaVersion = 8
1919
2020 // Store provides access to the SQLite database.
2121 type Store struct {
internal/store/store_test.go+10−13
@@ -123,21 +123,15 @@ func TestMemoryCRUD(t *testing.T) {
123123 }
124124
125125 // Add memories
126- m1, err := s.AddMemory(mysis.ID, MemoryRoleSystem, MemorySourceSystem, "You are a helpful assistant.", "")
127- if err != nil {
126+ if err := s.AddMemory(mysis.ID, MemoryRoleSystem, MemorySourceSystem, "You are a helpful assistant.", "", ""); err != nil {
128127 t.Fatalf("AddMemory() error: %v", err)
129128 }
130- if m1.ID == 0 {
131- t.Error("expected non-zero memory ID")
132- }
133129
134- m2, err := s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceDirect, "Hello!", "")
135- if err != nil {
130+ if err := s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceDirect, "Hello!", "", ""); err != nil {
136131 t.Fatalf("AddMemory() error: %v", err)
137132 }
138133
139- m3, err := s.AddMemory(mysis.ID, MemoryRoleAssistant, MemorySourceLLM, "Hi there!", "thinking...")
140- if err != nil {
134+ if err := s.AddMemory(mysis.ID, MemoryRoleAssistant, MemorySourceLLM, "Hi there!", "thinking...", ""); err != nil {
141135 t.Fatalf("AddMemory() error: %v", err)
142136 }
143137
@@ -149,6 +143,9 @@ func TestMemoryCRUD(t *testing.T) {
149143 if len(memories) != 3 {
150144 t.Errorf("expected 3 memories, got %d", len(memories))
151145 }
146+ if memories[0].ID == 0 {
147+ t.Error("expected non-zero memory ID")
148+ }
152149 if memories[2].Reasoning != "thinking..." {
153150 t.Errorf("expected reasoning=thinking..., got %q", memories[2].Reasoning)
154151 }
@@ -190,8 +187,8 @@ func TestMemoryCRUD(t *testing.T) {
190187 }
191188
192189 // Verify IDs for coverage
193- _ = m2.ID
194- _ = m3.ID
190+ _ = memories[1].ID
191+ _ = memories[2].ID
195192 }
196193
197194 func TestMemoryWithReasoning(t *testing.T) {
@@ -204,7 +201,7 @@ func TestMemoryWithReasoning(t *testing.T) {
204201 }
205202
206203 reasoning := "Step by step thinking"
207- _, err = s.AddMemory(mysis.ID, MemoryRoleAssistant, MemorySourceLLM, "", reasoning)
204+ err = s.AddMemory(mysis.ID, MemoryRoleAssistant, MemorySourceLLM, "", reasoning, "")
208205 if err != nil {
209206 t.Fatalf("AddMemory() error: %v", err)
210207 }
@@ -226,7 +223,7 @@ func TestCascadeDelete(t *testing.T) {
226223 defer cleanup()
227224
228225 mysis, _ := s.CreateMysis("cascade-test", "ollama", "llama3", 0.7)
229- s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceDirect, "test message", "")
226+ s.AddMemory(mysis.ID, MemoryRoleUser, MemorySourceDirect, "test message", "", "")
230227
231228 // Delete mysis should cascade to memories
232229 if err := s.DeleteMysis(mysis.ID); err != nil {