xonecas.io
60255
Zn

Zoea-Nova / files

Zoea-Nova / internal / core / commander.go

10.5 KB
1package core
2
3import (
4	"context"
5	"errors"
6	"fmt"
7	"sync"
8	"time"
9
10	"github.com/rs/zerolog/log"
11	"github.com/xonecas/zoea-nova/internal/config"
12	"github.com/xonecas/zoea-nova/internal/provider"
13	"github.com/xonecas/zoea-nova/internal/store"
14)
15
16// Commander orchestrates the swarm of myses.
17type Commander struct {
18	mu sync.RWMutex
19	wg sync.WaitGroup // Tracks running mysis goroutines
20
21	myses       map[string]*Mysis
22	store       *store.Store
23	registry    *provider.Registry
24	bus         *EventBus
25	config      *config.Config
26	mcpEndpoint string // MCP upstream endpoint for myses to create their own clients
27	maxMyses    int
28}
29
30// NewCommander creates a new commander.
31func NewCommander(s *store.Store, reg *provider.Registry, bus *EventBus, cfg *config.Config, mcpEndpoint string) *Commander {
32	return &Commander{
33		myses:       make(map[string]*Mysis),
34		store:       s,
35		registry:    reg,
36		bus:         bus,
37		config:      cfg,
38		mcpEndpoint: mcpEndpoint,
39		maxMyses:    cfg.Swarm.MaxMyses,
40	}
41}
42
43// LoadMyses loads existing myses from the store.
44// Myses are loaded in stopped state; they must be explicitly started.
45func (c *Commander) LoadMyses() error {
46	stored, err := c.store.ListMyses()
47	if err != nil {
48		return fmt.Errorf("list myses: %w", err)
49	}
50
51	c.mu.Lock()
52	defer c.mu.Unlock()
53
54	for _, sm := range stored {
55		p, err := c.registry.Create(sm.Provider, sm.Model, sm.Temperature)
56		if err != nil {
57			// Provider not available, skip mysis
58			continue
59		}
60
61		mysis := NewMysis(sm.ID, sm.Name, sm.CreatedAt, p, c.store, c.bus, c.mcpEndpoint, c)
62		c.myses[sm.ID] = mysis
63	}
64
65	return nil
66}
67
68// CreateMysis creates a new mysis with the given name and provider.
69func (c *Commander) CreateMysis(name, providerName string) (*Mysis, error) {
70	c.mu.Lock()
71	defer c.mu.Unlock()
72
73	if len(c.myses) >= c.maxMyses {
74		return nil, fmt.Errorf("max myses (%d) reached", c.maxMyses)
75	}
76
77	// Get provider config for model
78	provCfg, ok := c.config.Providers[providerName]
79	if !ok {
80		return nil, fmt.Errorf("provider config not found: %s", providerName)
81	}
82
83	// Create provider instance for this mysis
84	p, err := c.registry.Create(providerName, provCfg.Model, provCfg.Temperature)
85	if err != nil {
86		return nil, fmt.Errorf("create provider: %w", err)
87	}
88
89	// Create in store
90	stored, err := c.store.CreateMysis(name, providerName, provCfg.Model, provCfg.Temperature)
91	if err != nil {
92		return nil, fmt.Errorf("create mysis in store: %w", err)
93	}
94
95	// Create runtime mysis
96	mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, p, c.store, c.bus, c.mcpEndpoint, c)
97	c.myses[stored.ID] = mysis
98
99	// Emit event
100	c.bus.Publish(Event{
101		Type:      EventMysisCreated,
102		MysisID:   stored.ID,
103		MysisName: stored.Name,
104		Timestamp: time.Now(),
105	})
106
107	return mysis, nil
108}
109
110// DeleteMysis removes a mysis from the swarm.
111func (c *Commander) DeleteMysis(id string, purgeMemories bool) error {
112	c.mu.Lock()
113	mysis, ok := c.myses[id]
114	if !ok {
115		c.mu.Unlock()
116		return fmt.Errorf("mysis not found: %s", id)
117	}
118
119	delete(c.myses, id)
120	c.mu.Unlock()
121
122	// Stop if running (outside of commander lock to avoid deadlock)
123	if mysis.State() == MysisStateRunning {
124		mysis.Stop()
125	}
126	mysis.releaseCurrentAccount()
127
128	// Delete from store (memories cascade)
129	if err := c.store.DeleteMysis(id); err != nil {
130		return fmt.Errorf("delete mysis from store: %w", err)
131	}
132
133	// Emit event
134	c.bus.Publish(Event{
135		Type:      EventMysisDeleted,
136		MysisID:   id,
137		MysisName: mysis.Name(),
138		Timestamp: time.Now(),
139	})
140
141	return nil
142}
143
144// GetMysis returns a mysis by ID.
145func (c *Commander) GetMysis(id string) (*Mysis, error) {
146	c.mu.RLock()
147	defer c.mu.RUnlock()
148
149	mysis, ok := c.myses[id]
150	if !ok {
151		return nil, fmt.Errorf("mysis not found: %s", id)
152	}
153	return mysis, nil
154}
155
156// ListMyses returns all myses.
157func (c *Commander) ListMyses() []*Mysis {
158	c.mu.RLock()
159	defer c.mu.RUnlock()
160
161	myses := make([]*Mysis, 0, len(c.myses))
162	for _, m := range c.myses {
163		myses = append(myses, m)
164	}
165	return myses
166}
167
168// StartMysis starts a mysis by ID.
169func (c *Commander) StartMysis(id string) error {
170	mysis, err := c.GetMysis(id)
171	if err != nil {
172		return err
173	}
174
175	// Don't increment WaitGroup here - mysis.Start() will do it
176	// This avoids double-counting when restarting errored myses
177	return mysis.Start()
178}
179
180// StopMysis stops a mysis by ID.
181func (c *Commander) StopMysis(id string) error {
182	mysis, err := c.GetMysis(id)
183	if err != nil {
184		return err
185	}
186
187	return mysis.Stop()
188}
189
190// ConfigureMysis updates a mysis provider and model.
191func (c *Commander) ConfigureMysis(id, providerName, model string) error {
192	c.mu.Lock()
193	mysis, ok := c.myses[id]
194	if !ok {
195		c.mu.Unlock()
196		return fmt.Errorf("mysis not found: %s", id)
197	}
198	c.mu.Unlock()
199
200	// Get provider config
201	provCfg, ok := c.config.Providers[providerName]
202	if !ok {
203		return fmt.Errorf("provider config not found: %s", providerName)
204	}
205	temperature := provCfg.Temperature
206
207	// Get new provider
208	p, err := c.registry.Create(providerName, model, temperature)
209	if err != nil {
210		return fmt.Errorf("create provider: %w", err)
211	}
212
213	// Update store
214	if err := c.store.UpdateMysisConfig(id, providerName, model, temperature); err != nil {
215		return fmt.Errorf("update store: %w", err)
216	}
217
218	// Update runtime
219	mysis.SetProvider(p)
220
221	// Emit event
222	c.bus.Publish(Event{
223		Type:      EventMysisConfigChanged,
224		MysisID:   id,
225		MysisName: mysis.Name(),
226		Config: &ConfigChangeData{
227			Provider: providerName,
228			Model:    model,
229		},
230		Timestamp: time.Now(),
231	})
232
233	return nil
234}
235
236// SendMessage sends a message to a specific mysis (synchronous).
237func (c *Commander) SendMessage(id, content string) error {
238	mysis, err := c.GetMysis(id)
239	if err != nil {
240		return err
241	}
242	return mysis.SendMessage(content, store.MemorySourceDirect)
243}
244
245// SendMessageAsync sends a message to a specific mysis without waiting for processing.
246// Returns immediately after validating the mysis exists.
247// State validation is done inside mysis.SendMessage.
248func (c *Commander) SendMessageAsync(id, content string) error {
249	mysis, err := c.GetMysis(id)
250	if err != nil {
251		return err
252	}
253	// State validation is done inside mysis.SendMessage
254	go func() {
255		if err := mysis.SendMessage(content, store.MemorySourceDirect); err != nil {
256			// Error is published to bus by mysis.SendMessage
257		}
258	}()
259	return nil
260}
261
262// Broadcast sends a message to all running myses.
263// Stores the message immediately and triggers async processing.
264// Returns quickly without waiting for LLM processing.
265func (c *Commander) Broadcast(content string) error {
266	c.mu.RLock()
267	myses := make([]*Mysis, 0)
268	for _, m := range c.myses {
269		// Include myses in idle or running state (can accept messages)
270		if validateCanAcceptMessage(m.State()) == nil {
271			myses = append(myses, m)
272		}
273	}
274	c.mu.RUnlock()
275
276	// Check if any myses can receive broadcast
277	if len(myses) == 0 {
278		return fmt.Errorf("no myses available to receive broadcast (all stopped or errored)")
279	}
280
281	// Emit broadcast event
282	c.bus.Publish(Event{
283		Type:      EventBroadcast,
284		Message:   &MessageData{Role: "user", Content: content},
285		Timestamp: time.Now(),
286	})
287
288	// Queue broadcast to each mysis (non-blocking)
289	var errs []error
290	for _, m := range myses {
291		if err := m.QueueBroadcast(content, ""); err != nil {
292			errs = append(errs, fmt.Errorf("mysis %s: %w", m.ID(), err))
293		}
294	}
295
296	if len(errs) > 0 {
297		return fmt.Errorf("broadcast failed for %d mysis: %w", len(errs), errors.Join(errs...))
298	}
299	return nil
300}
301
302// BroadcastFrom sends a message to all running myses except the sender.
303func (c *Commander) BroadcastFrom(senderID, content string) error {
304	c.mu.RLock()
305	myses := make([]*Mysis, 0)
306	for _, m := range c.myses {
307		// Include myses in idle or running state (can accept messages), excluding sender
308		if validateCanAcceptMessage(m.State()) == nil && m.ID() != senderID {
309			myses = append(myses, m)
310		}
311	}
312	c.mu.RUnlock()
313
314	if len(myses) == 0 {
315		return fmt.Errorf("no recipients for broadcast (sender excluded or all stopped/errored)")
316	}
317
318	// Emit broadcast event
319	c.bus.Publish(Event{
320		Type:      EventBroadcast,
321		Message:   &MessageData{Role: "user", Content: content},
322		Timestamp: time.Now(),
323	})
324
325	var errs []error
326	for _, m := range myses {
327		if err := m.SendMessageFrom(content, store.MemorySourceBroadcast, senderID); err != nil {
328			errs = append(errs, fmt.Errorf("mysis %s: %w", m.ID(), err))
329		}
330	}
331
332	if len(errs) > 0 {
333		return fmt.Errorf("broadcast failed for %d mysis: %w", len(errs), errors.Join(errs...))
334	}
335	return nil
336}
337
338// BroadcastAsync sends a message to all running myses without waiting for processing.
339// Returns immediately after validating at least one mysis is running.
340func (c *Commander) BroadcastAsync(content string) error {
341	return c.BroadcastFrom("", content)
342}
343
344// StopAll stops all running myses with a 10-second timeout.
345func (c *Commander) StopAll() {
346	c.mu.RLock()
347	myses := make([]*Mysis, 0)
348	for _, m := range c.myses {
349		myses = append(myses, m)
350	}
351	c.mu.RUnlock()
352
353	// Stop with timeout
354	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
355	defer cancel()
356
357	done := make(chan struct{})
358	go func() {
359		// Stop all running myses
360		for _, m := range myses {
361			if m.State() == MysisStateRunning {
362				if err := m.Stop(); err != nil {
363					log.Warn().Err(err).Str("mysis", m.Name()).Msg("Failed to stop mysis")
364				}
365			}
366		}
367		// Wait for all mysis goroutines to complete
368		c.wg.Wait()
369		close(done)
370	}()
371
372	select {
373	case <-done:
374		log.Info().Int("count", len(myses)).Msg("All myses stopped")
375	case <-ctx.Done():
376		log.Warn().Msg("StopAll timeout - some myses may still be running")
377	}
378}
379
380// MysisCount returns the current number of myses.
381func (c *Commander) MysisCount() int {
382	c.mu.RLock()
383	defer c.mu.RUnlock()
384	return len(c.myses)
385}
386
387// MaxMyses returns the maximum allowed myses.
388func (c *Commander) MaxMyses() int {
389	return c.maxMyses
390}
391
392// GetStateCounts returns the count of myses in each state.
393func (c *Commander) GetStateCounts() map[string]int {
394	c.mu.RLock()
395	defer c.mu.RUnlock()
396
397	counts := map[string]int{
398		"running": 0,
399		"idle":    0,
400		"stopped": 0,
401		"errored": 0,
402	}
403
404	for _, m := range c.myses {
405		state := string(m.State())
406		counts[state]++
407	}
408
409	return counts
410}
411
412// Store returns the store for direct access (e.g., for testing).
413func (c *Commander) Store() *store.Store {
414	return c.store
415}
416
417// AggregateTick returns the maximum lastServerTick across all myses.
418// Returns 0 if no myses exist or if no mysis has received tick data.
419func (c *Commander) AggregateTick() int64 {
420	c.mu.RLock()
421	defer c.mu.RUnlock()
422
423	var maxTick int64
424	for _, m := range c.myses {
425		m.mu.RLock()
426		tick := m.lastServerTick
427		m.mu.RUnlock()
428
429		if tick > maxTick {
430			maxTick = tick
431		}
432	}
433
434	return maxTick
435}