xonecas.io
6119
My

mysis / files

mysis / internal / session / session.go

5.8 KB
1package session
2
3import (
4	"fmt"
5	"time"
6
7	"github.com/google/uuid"
8	"github.com/rs/zerolog/log"
9	"github.com/xonecas/mysis/internal/config"
10	"github.com/xonecas/mysis/internal/provider"
11	"github.com/xonecas/mysis/internal/store"
12)
13
14// Manager handles session creation, resumption, and management.
15type Manager struct {
16	db *store.Store
17}
18
19// NewManager creates a new session manager.
20func NewManager(db *store.Store) *Manager {
21	return &Manager{db: db}
22}
23
24// InitializeResult holds the result of session initialization.
25type InitializeResult struct {
26	SessionID   string
27	SessionInfo string
28}
29
30// Initialize creates or resumes a session.
31func (m *Manager) Initialize(sessionName, provider, model string) (*InitializeResult, error) {
32	var sessionID string
33	var sessionInfo string
34
35	if sessionName != "" {
36		// Try to resume by name
37		sess, err := m.db.GetSessionByName(sessionName)
38		if err != nil {
39			return nil, fmt.Errorf("failed to load session: %w", err)
40		}
41		if sess != nil {
42			sessionID = sess.ID
43			sessionInfo = fmt.Sprintf("Resumed session: %s", sessionName)
44			log.Info().Str("session_id", sessionID).Str("name", sessionName).Msg("Resumed session")
45		} else {
46			// Create new named session
47			sessionID = uuid.New().String()
48			if err := m.db.CreateSession(sessionID, provider, model, &sessionName); err != nil {
49				return nil, fmt.Errorf("failed to create session: %w", err)
50			}
51			sessionInfo = fmt.Sprintf("New session: %s", sessionName)
52			log.Info().Str("session_id", sessionID).Str("name", sessionName).Msg("Created named session")
53		}
54	} else {
55		// Create anonymous session
56		sessionID = uuid.New().String()
57		if err := m.db.CreateSession(sessionID, provider, model, nil); err != nil {
58			return nil, fmt.Errorf("failed to create session: %w", err)
59		}
60		sessionInfo = fmt.Sprintf("Session: %s", sessionID[:8])
61		log.Info().Str("session_id", sessionID).Msg("Created anonymous session")
62	}
63
64	return &InitializeResult{
65		SessionID:   sessionID,
66		SessionInfo: sessionInfo,
67	}, nil
68}
69
70// LoadHistory loads message history for a session.
71func (m *Manager) LoadHistory(sessionID string) ([]provider.Message, error) {
72	history, err := m.db.LoadMessages(sessionID)
73	if err != nil {
74		return nil, fmt.Errorf("failed to load history: %w", err)
75	}
76	if len(history) > 0 {
77		log.Info().Int("count", len(history)).Msg("Loaded message history")
78	}
79	return history, nil
80}
81
82// SaveMessage saves a message to the session history.
83func (m *Manager) SaveMessage(sessionID string, msg provider.Message) error {
84	if err := m.db.SaveMessage(sessionID, msg); err != nil {
85		log.Warn().Err(err).Msg("Failed to save message to database")
86		return err
87	}
88	return nil
89}
90
91// SelectProviderResult holds the result of provider selection.
92type SelectProviderResult struct {
93	Provider string
94	Model    string
95}
96
97// SelectProvider determines which provider and model to use.
98func (m *Manager) SelectProvider(cfg *config.Config, sessionName, providerFlag string) (*SelectProviderResult, error) {
99	var selectedProvider string
100	var selectedModel string
101
102	// Check if we're resuming a session to use its provider
103	if sessionName != "" && providerFlag == "" {
104		sess, err := m.db.GetSessionByName(sessionName)
105		if err != nil {
106			return nil, fmt.Errorf("failed to check session: %w", err)
107		}
108		if sess != nil {
109			// Resuming existing session - use its provider
110			selectedProvider = sess.Provider
111			selectedModel = sess.Model
112			log.Debug().
113				Str("session", sessionName).
114				Str("provider", selectedProvider).
115				Str("model", selectedModel).
116				Msg("Using provider from existing session")
117			return &SelectProviderResult{
118				Provider: selectedProvider,
119				Model:    selectedModel,
120			}, nil
121		}
122	}
123
124	// If provider not determined from session, use flag or default
125	selectedProvider = providerFlag
126	if selectedProvider == "" {
127		// Use default provider from config
128		if cfg.DefaultProvider != "" {
129			selectedProvider = cfg.DefaultProvider
130		} else {
131			// Fallback: use first provider (non-deterministic for backwards compatibility)
132			for name := range cfg.Providers {
133				selectedProvider = name
134				break
135			}
136		}
137	}
138
139	if selectedProvider == "" {
140		return nil, fmt.Errorf("no provider configured")
141	}
142
143	// Get model from config
144	providerCfg, ok := cfg.Providers[selectedProvider]
145	if !ok {
146		return nil, fmt.Errorf("provider '%s' not found in config", selectedProvider)
147	}
148	selectedModel = providerCfg.Model
149
150	return &SelectProviderResult{
151		Provider: selectedProvider,
152		Model:    selectedModel,
153	}, nil
154}
155
156// List returns recent sessions.
157func (m *Manager) List(limit int) ([]store.Session, error) {
158	sessions, err := m.db.ListSessions(limit)
159	if err != nil {
160		return nil, fmt.Errorf("list sessions: %w", err)
161	}
162	return sessions, nil
163}
164
165// DeleteByName deletes a session by name.
166func (m *Manager) DeleteByName(name string) error {
167	// Get session to verify it exists
168	sess, err := m.db.GetSessionByName(name)
169	if err != nil {
170		return fmt.Errorf("get session: %w", err)
171	}
172	if sess == nil {
173		return fmt.Errorf("session '%s' not found", name)
174	}
175
176	// Delete
177	if err := m.db.DeleteSessionByName(name); err != nil {
178		return fmt.Errorf("delete session: %w", err)
179	}
180
181	return nil
182}
183
184// GetByName retrieves a session by name.
185func (m *Manager) GetByName(name string) (*store.Session, error) {
186	sess, err := m.db.GetSessionByName(name)
187	if err != nil {
188		return nil, fmt.Errorf("get session: %w", err)
189	}
190	return sess, nil
191}
192
193// FormatDuration formats a duration in human-readable form.
194func FormatDuration(d time.Duration) string {
195	if d < time.Minute {
196		return "just now"
197	}
198	if d < time.Hour {
199		mins := int(d.Minutes())
200		if mins == 1 {
201			return "1 minute"
202		}
203		return fmt.Sprintf("%d minutes", mins)
204	}
205	if d < 24*time.Hour {
206		hours := int(d.Hours())
207		if hours == 1 {
208			return "1 hour"
209		}
210		return fmt.Sprintf("%d hours", hours)
211	}
212	days := int(d.Hours() / 24)
213	if days == 1 {
214		return "1 day"
215	}
216	return fmt.Sprintf("%d days", days)
217}