Loki/internal/ajean/store.go

package ajean

import (
	"encoding/json"
	"fmt"
	"os"
	"path/filepath"
	"sync"
	"time"

	bolt "go.etcd.io/bbolt"
)

// store.go — l'unique endroit où AJEAN écrit son état.
//
// Avant, chaque réglage avait son fichier : config.env, webprefs.json,
// conversation.json, .api_key, .link_token, .agent_enabled, model_dirs.json…
// Une douzaine de formats, une douzaine de façons de rater une écriture
// concurrente, et un dossier de données illisible. Tout ça tient désormais dans
// une seule base bbolt — pur Go, un seul fichier, transactionnelle.
//
// Ce qui N'EST PAS en base, et pourquoi : les presets (presets/*.env) et les
// pages de mémoire (memory/*.md) restent des fichiers, parce qu'ils sont faits
// pour être lus, édités et sauvegardés à la main. Les modèles (.gguf) et les
// backends compilés restent des fichiers, évidemment.

// Buckets. Un par nature de donnée : ça garde les itérations bornées et rend le
// contenu de la base lisible au débogage.
const (
	bkConfig = "config" // configuration de llama-server (ex-config.env)
	bkPrefs  = "prefs"  // préférences de l'UI web
	bkState  = "state"  // clés, jetons, drapeaux, listes de dossiers, MCP
	bkChat   = "chat"   // conversation partagée
)

var (
	dbOnce sync.Once
	dbConn *bolt.DB
	dbErr  error
)

func dbPath() string { return filepath.Join(AjeanHome(), "ajean.db") }

// db ouvre la base à la première utilisation et la garde ouverte pour la durée
// du process. bbolt prend un verrou exclusif sur le fichier : le délai d'attente
// évite qu'un second process (l'app lancée deux fois) se bloque indéfiniment.
func db() (*bolt.DB, error) {
	dbOnce.Do(func() {
		if err := os.MkdirAll(AjeanHome(), 0o755); err != nil {
			dbErr = err
			return
		}
		d, err := bolt.Open(dbPath(), 0o600, &bolt.Options{Timeout: 3 * time.Second})
		if err != nil {
			dbErr = fmt.Errorf("base %s inaccessible : %w", dbPath(), err)
			return
		}
		err = d.Update(func(tx *bolt.Tx) error {
			for _, b := range []string{bkConfig, bkPrefs, bkState, bkChat} {
				if _, err := tx.CreateBucketIfNotExists([]byte(b)); err != nil {
					return err
				}
			}
			return nil
		})
		if err != nil {
			d.Close()
			dbErr = err
			return
		}
		dbConn = d
	})
	return dbConn, dbErr
}

// getBytes lit une valeur. Une base inaccessible se comporte comme une base
// vide : les appelants sont des lecteurs de réglages, aucun n'a de recours utile
// face à une erreur d'E/S, et tous ont déjà un défaut.
func getBytes(bucket, key string) []byte {
	d, err := db()
	if err != nil {
		return nil
	}
	var out []byte
	_ = d.View(func(tx *bolt.Tx) error {
		if v := tx.Bucket([]byte(bucket)).Get([]byte(key)); v != nil {
			out = append([]byte(nil), v...) // la valeur ne survit pas à la transaction
		}
		return nil
	})
	return out
}

// putBytes écrit une valeur. Une valeur nil supprime la clé.
func putBytes(bucket, key string, val []byte) error {
	d, err := db()
	if err != nil {
		return err
	}
	return d.Update(func(tx *bolt.Tx) error {
		b := tx.Bucket([]byte(bucket))
		if val == nil {
			return b.Delete([]byte(key))
		}
		return b.Put([]byte(key), val)
	})
}

func getStr(bucket, key string) string { return string(getBytes(bucket, key)) }

// putStr écrit une chaîne ; une chaîne vide supprime la clé, pour que « absent »
// et « vide » ne soient jamais deux états distincts à distinguer.
func putStr(bucket, key, val string) error {
	if val == "" {
		return putBytes(bucket, key, nil)
	}
	return putBytes(bucket, key, []byte(val))
}

func getBool(bucket, key string) bool { return getStr(bucket, key) == "1" }

func putBool(bucket, key string, on bool) error {
	if !on {
		return putBytes(bucket, key, nil)
	}
	return putStr(bucket, key, "1")
}

// getJSON décode une valeur JSON dans dst. Renvoie false si la clé est absente
// ou illisible — dans les deux cas l'appelant garde son zéro.
func getJSON(bucket, key string, dst any) bool {
	b := getBytes(bucket, key)
	if len(b) == 0 {
		return false
	}
	return json.Unmarshal(b, dst) == nil
}

func putJSON(bucket, key string, v any) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}
	return putBytes(bucket, key, b)
}

// allKV renvoie tout le contenu d'un bucket. Utilisé par la configuration, dont
// les clés ne sont pas connues à l'avance (EXTRA_ARGS et consorts).
func allKV(bucket string) map[string]string {
	m := map[string]string{}
	d, err := db()
	if err != nil {
		return m
	}
	_ = d.View(func(tx *bolt.Tx) error {
		return tx.Bucket([]byte(bucket)).ForEach(func(k, v []byte) error {
			m[string(k)] = string(v)
			return nil
		})
	})
	return m
}

// replaceKV remplace tout le contenu d'un bucket en une seule transaction.
// C'est ce qu'exige l'application d'un preset : à aucun instant la config ne
// doit être un mélange de l'ancienne et de la nouvelle.
func replaceKV(bucket string, m map[string]string) error {
	d, err := db()
	if err != nil {
		return err
	}
	return d.Update(func(tx *bolt.Tx) error {
		if err := tx.DeleteBucket([]byte(bucket)); err != nil {
			return err
		}
		b, err := tx.CreateBucket([]byte(bucket))
		if err != nil {
			return err
		}
		for k, v := range m {
			if v == "" {
				continue
			}
			if err := b.Put([]byte(k), []byte(v)); err != nil {
				return err
			}
		}
		return nil
	})
}