xonecas.io
60255
Zn

Zoea-Nova / files

Zoea-Nova / internal / store / myses.go

3.8 KB
1package store
2
3import (
4	"database/sql"
5	"fmt"
6	"time"
7
8	"github.com/google/uuid"
9)
10
11// MysisState represents the current state of a mysis.
12type MysisState string
13
14const (
15	MysisStateIdle    MysisState = "idle"
16	MysisStateRunning MysisState = "running"
17	MysisStateStopped MysisState = "stopped"
18	MysisStateErrored MysisState = "errored"
19)
20
21// Mysis represents a stored mysis record.
22type Mysis struct {
23	ID          string
24	Name        string
25	Provider    string
26	Model       string
27	Temperature float64
28	State       MysisState
29	CreatedAt   time.Time
30	UpdatedAt   time.Time
31}
32
33// CreateMysis creates a new mysis record.
34func (s *Store) CreateMysis(name, provider, model string, temperature float64) (*Mysis, error) {
35	id := uuid.New().String()
36	now := time.Now().UTC()
37
38	_, err := s.db.Exec(`
39		INSERT INTO myses (id, name, provider, model, temperature, state, created_at, updated_at)
40		VALUES (?, ?, ?, ?, ?, ?, ?, ?)
41	`, id, name, provider, model, temperature, MysisStateIdle, now, now)
42	if err != nil {
43		return nil, fmt.Errorf("insert mysis: %w", err)
44	}
45
46	return &Mysis{
47		ID:          id,
48		Name:        name,
49		Provider:    provider,
50		Model:       model,
51		Temperature: temperature,
52		State:       MysisStateIdle,
53		CreatedAt:   now,
54		UpdatedAt:   now,
55	}, nil
56}
57
58// GetMysis retrieves a mysis by ID.
59func (s *Store) GetMysis(id string) (*Mysis, error) {
60	row := s.db.QueryRow(`
61		SELECT id, name, provider, model, temperature, state, created_at, updated_at
62		FROM myses WHERE id = ?
63	`, id)
64
65	return scanMysis(row)
66}
67
68// ListMyses returns all myses.
69func (s *Store) ListMyses() ([]*Mysis, error) {
70	rows, err := s.db.Query(`
71		SELECT id, name, provider, model, temperature, state, created_at, updated_at
72		FROM myses ORDER BY created_at ASC
73	`)
74	if err != nil {
75		return nil, fmt.Errorf("query myses: %w", err)
76	}
77	defer rows.Close()
78
79	var myses []*Mysis
80	for rows.Next() {
81		mysis, err := scanMysisRows(rows)
82		if err != nil {
83			return nil, err
84		}
85		myses = append(myses, mysis)
86	}
87
88	return myses, rows.Err()
89}
90
91// UpdateMysisState updates a mysis state.
92func (s *Store) UpdateMysisState(id string, state MysisState) error {
93	result, err := s.db.Exec(`
94		UPDATE myses SET state = ?, updated_at = ? WHERE id = ?
95	`, state, time.Now().UTC(), id)
96	if err != nil {
97		return fmt.Errorf("update mysis state: %w", err)
98	}
99
100	n, _ := result.RowsAffected()
101	if n == 0 {
102		return sql.ErrNoRows
103	}
104	return nil
105}
106
107// UpdateMysisConfig updates a mysis provider and model.
108func (s *Store) UpdateMysisConfig(id, provider, model string, temperature float64) error {
109	result, err := s.db.Exec(`
110		UPDATE myses SET provider = ?, model = ?, temperature = ?, updated_at = ? WHERE id = ?
111	`, provider, model, temperature, time.Now().UTC(), id)
112	if err != nil {
113		return fmt.Errorf("update mysis config: %w", err)
114	}
115
116	n, _ := result.RowsAffected()
117	if n == 0 {
118		return sql.ErrNoRows
119	}
120	return nil
121}
122
123// DeleteMysis deletes a mysis and its memories (via CASCADE).
124func (s *Store) DeleteMysis(id string) error {
125	result, err := s.db.Exec(`DELETE FROM myses WHERE id = ?`, id)
126	if err != nil {
127		return fmt.Errorf("delete mysis: %w", err)
128	}
129
130	n, _ := result.RowsAffected()
131	if n == 0 {
132		return sql.ErrNoRows
133	}
134	return nil
135}
136
137// CountMyses returns the total number of myses.
138func (s *Store) CountMyses() (int, error) {
139	var count int
140	err := s.db.QueryRow(`SELECT COUNT(*) FROM myses`).Scan(&count)
141	return count, err
142}
143
144func scanMysis(row *sql.Row) (*Mysis, error) {
145	var m Mysis
146	err := row.Scan(&m.ID, &m.Name, &m.Provider, &m.Model, &m.Temperature, &m.State, &m.CreatedAt, &m.UpdatedAt)
147	if err != nil {
148		return nil, err
149	}
150	return &m, nil
151}
152
153func scanMysisRows(rows *sql.Rows) (*Mysis, error) {
154	var m Mysis
155	err := rows.Scan(&m.ID, &m.Name, &m.Provider, &m.Model, &m.Temperature, &m.State, &m.CreatedAt, &m.UpdatedAt)
156	if err != nil {
157		return nil, err
158	}
159	return &m, nil
160}