genesis-ai-cli 7.4.5

package/dist/src/persistence/index.js

@@ -0,0 +1,763 @@
+"use strict";
+/**
+ * Genesis 6.0 - State Persistence
+ *
+ * Save and load Genesis state to/from disk.
+ * Supports JSON format with optional compression.
+ *
+ * State includes:
+ * - Memory (episodic, semantic, procedural)
+ * - Conversation history
+ * - Session metadata
+ * - Configuration
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = exports.StateStore = void 0;
+exports.createStateStore = createStateStore;
+exports.getStateStore = getStateStore;
+exports.resetStateStore = resetStateStore;
+exports.getSessionManager = getSessionManager;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+// ============================================================================
+// Default Paths
+// ============================================================================
+const DEFAULT_DATA_DIR = path.join(process.env.HOME || '.', '.genesis');
+const STATE_FILE = 'state.json';
+const BACKUP_DIR = 'backups';
+// ============================================================================
+// State Store Class
+// ============================================================================
+class StateStore {
+    dataDir;
+    statePath;
+    backupDir;
+    options;
+    autoSaveTimer = null;
+    dirty = false;
+    // In-memory state
+    state;
+    constructor(options = {}) {
+        this.options = options;
+        this.dataDir = options.dataDir || DEFAULT_DATA_DIR;
+        this.statePath = path.join(this.dataDir, STATE_FILE);
+        this.backupDir = path.join(this.dataDir, BACKUP_DIR);
+        // Initialize with empty state
+        this.state = this.createEmptyState();
+        // Ensure directories exist
+        this.ensureDirectories();
+        // Try to load existing state
+        this.loadSync();
+        // Start auto-save if enabled
+        if (options.autoSave) {
+            this.startAutoSave(options.autoSaveIntervalMs || 60000);
+        }
+    }
+    // ============================================================================
+    // Core Methods
+    // ============================================================================
+    /**
+     * Save state to disk
+     */
+    async save() {
+        try {
+            // Update metadata
+            this.state.lastModified = new Date();
+            this.state.checksum = this.calculateChecksum(this.state);
+            // Create backup before overwriting
+            await this.backup();
+            // Write state
+            const json = JSON.stringify(this.state, null, 2);
+            await fs.promises.writeFile(this.statePath, json, 'utf-8');
+            this.dirty = false;
+            this.options.onSave?.(this.state);
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.options.onError?.(err);
+            throw err;
+        }
+    }
+    /**
+     * Save state synchronously
+     */
+    saveSync() {
+        try {
+            this.state.lastModified = new Date();
+            this.state.checksum = this.calculateChecksum(this.state);
+            // Backup
+            this.backupSync();
+            // Write
+            const json = JSON.stringify(this.state, null, 2);
+            fs.writeFileSync(this.statePath, json, 'utf-8');
+            this.dirty = false;
+            this.options.onSave?.(this.state);
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.options.onError?.(err);
+            throw err;
+        }
+    }
+    /**
+     * Load state from disk
+     */
+    async load() {
+        try {
+            if (!fs.existsSync(this.statePath)) {
+                return this.state;
+            }
+            const json = await fs.promises.readFile(this.statePath, 'utf-8');
+            const loaded = JSON.parse(json);
+            // Validate checksum
+            const expectedChecksum = this.calculateChecksum(loaded);
+            if (loaded.checksum && loaded.checksum !== expectedChecksum) {
+                console.warn('[StateStore] Checksum mismatch - state may be corrupted');
+            }
+            // Merge with empty state to ensure all fields exist
+            this.state = this.mergeState(this.createEmptyState(), loaded);
+            this.options.onLoad?.(this.state);
+            return this.state;
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.options.onError?.(err);
+            throw err;
+        }
+    }
+    /**
+     * Load state synchronously
+     */
+    loadSync() {
+        try {
+            if (!fs.existsSync(this.statePath)) {
+                return this.state;
+            }
+            const json = fs.readFileSync(this.statePath, 'utf-8');
+            const loaded = JSON.parse(json);
+            this.state = this.mergeState(this.createEmptyState(), loaded);
+            this.options.onLoad?.(this.state);
+            return this.state;
+        }
+        catch (error) {
+            // If loading fails, keep empty state
+            console.warn('[StateStore] Failed to load state:', error);
+            return this.state;
+        }
+    }
+    /**
+     * Get current state
+     */
+    getState() {
+        return this.state;
+    }
+    /**
+     * Update state (partial update)
+     */
+    update(updates) {
+        this.state = this.mergeState(this.state, updates);
+        this.dirty = true;
+    }
+    /**
+     * Check if state has unsaved changes
+     */
+    isDirty() {
+        return this.dirty;
+    }
+    // ============================================================================
+    // Memory Operations
+    // ============================================================================
+    /**
+     * Update memory state
+     */
+    updateMemory(memory) {
+        this.state.memory = { ...this.state.memory, ...memory };
+        this.dirty = true;
+    }
+    /**
+     * Add episodic memory
+     */
+    addEpisode(episode) {
+        this.state.memory.episodic.push(episode);
+        this.state.memory.stats.totalEpisodes++;
+        this.dirty = true;
+    }
+    /**
+     * Add semantic memory
+     */
+    addFact(fact) {
+        this.state.memory.semantic.push(fact);
+        this.state.memory.stats.totalFacts++;
+        this.dirty = true;
+    }
+    /**
+     * Add procedural memory
+     */
+    addSkill(skill) {
+        this.state.memory.procedural.push(skill);
+        this.state.memory.stats.totalSkills++;
+        this.dirty = true;
+    }
+    // ============================================================================
+    // Conversation Operations
+    // ============================================================================
+    /**
+     * Update conversation history
+     */
+    updateConversation(messages, tokens) {
+        this.state.conversation.history = messages;
+        this.state.conversation.totalMessages = messages.length;
+        if (tokens) {
+            this.state.conversation.totalTokens += tokens;
+        }
+        this.dirty = true;
+    }
+    /**
+     * Add message to conversation
+     */
+    addMessage(message) {
+        this.state.conversation.history.push(message);
+        this.state.conversation.totalMessages++;
+        this.dirty = true;
+    }
+    /**
+     * Clear conversation history
+     */
+    clearConversation() {
+        this.state.conversation.history = [];
+        this.dirty = true;
+    }
+    // ============================================================================
+    // Session Operations
+    // ============================================================================
+    /**
+     * Record an interaction
+     */
+    recordInteraction() {
+        this.state.session.interactions++;
+        this.state.session.lastActivity = new Date();
+        this.dirty = true;
+    }
+    /**
+     * Start new session
+     */
+    newSession() {
+        this.state.session = {
+            id: crypto.randomUUID(),
+            startTime: new Date(),
+            interactions: 0,
+            lastActivity: new Date(),
+        };
+        this.dirty = true;
+    }
+    // ============================================================================
+    // Backup Operations
+    // ============================================================================
+    /**
+     * Create backup of current state
+     */
+    async backup() {
+        if (!fs.existsSync(this.statePath)) {
+            return null;
+        }
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const backupPath = path.join(this.backupDir, `state-${timestamp}.json`);
+        await fs.promises.copyFile(this.statePath, backupPath);
+        // Clean old backups
+        await this.cleanOldBackups();
+        return backupPath;
+    }
+    /**
+     * Create backup synchronously
+     */
+    backupSync() {
+        if (!fs.existsSync(this.statePath)) {
+            return null;
+        }
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const backupPath = path.join(this.backupDir, `state-${timestamp}.json`);
+        fs.copyFileSync(this.statePath, backupPath);
+        this.cleanOldBackupsSync();
+        return backupPath;
+    }
+    /**
+     * List available backups
+     */
+    listBackups() {
+        if (!fs.existsSync(this.backupDir)) {
+            return [];
+        }
+        return fs.readdirSync(this.backupDir)
+            .filter(f => f.endsWith('.json'))
+            .sort()
+            .reverse();
+    }
+    /**
+     * Restore from backup
+     */
+    async restoreBackup(backupName) {
+        const backupPath = path.join(this.backupDir, backupName);
+        if (!fs.existsSync(backupPath)) {
+            throw new Error(`Backup not found: ${backupName}`);
+        }
+        // Backup current state first
+        await this.backup();
+        // Copy backup to state file
+        await fs.promises.copyFile(backupPath, this.statePath);
+        // Reload
+        await this.load();
+    }
+    // ============================================================================
+    // Export/Import
+    // ============================================================================
+    /**
+     * Export state to a portable format
+     */
+    async export(outputPath) {
+        const exportData = {
+            ...this.state,
+            exportedAt: new Date(),
+            exportVersion: '1.0',
+        };
+        const json = JSON.stringify(exportData, null, 2);
+        await fs.promises.writeFile(outputPath, json, 'utf-8');
+    }
+    /**
+     * Import state from file
+     */
+    async import(inputPath, merge = false) {
+        const json = await fs.promises.readFile(inputPath, 'utf-8');
+        const imported = JSON.parse(json);
+        if (merge) {
+            // Merge with current state
+            this.state = this.mergeState(this.state, imported);
+        }
+        else {
+            // Replace state
+            this.state = this.mergeState(this.createEmptyState(), imported);
+        }
+        this.dirty = true;
+        await this.save();
+    }
+    // ============================================================================
+    // Auto-Save
+    // ============================================================================
+    /**
+     * Start auto-save timer
+     */
+    startAutoSave(intervalMs) {
+        this.stopAutoSave();
+        this.autoSaveTimer = setInterval(async () => {
+            if (this.dirty) {
+                try {
+                    await this.save();
+                }
+                catch (error) {
+                    console.error('[StateStore] Auto-save failed:', error);
+                }
+            }
+        }, intervalMs);
+    }
+    /**
+     * Stop auto-save timer
+     */
+    stopAutoSave() {
+        if (this.autoSaveTimer) {
+            clearInterval(this.autoSaveTimer);
+            this.autoSaveTimer = null;
+        }
+    }
+    // ============================================================================
+    // Cleanup
+    // ============================================================================
+    /**
+     * Reset state to empty
+     */
+    reset() {
+        this.state = this.createEmptyState();
+        this.dirty = true;
+    }
+    /**
+     * Delete all persisted data
+     */
+    async purge() {
+        this.stopAutoSave();
+        if (fs.existsSync(this.statePath)) {
+            await fs.promises.unlink(this.statePath);
+        }
+        if (fs.existsSync(this.backupDir)) {
+            const files = await fs.promises.readdir(this.backupDir);
+            for (const file of files) {
+                await fs.promises.unlink(path.join(this.backupDir, file));
+            }
+        }
+        this.reset();
+    }
+    /**
+     * Close and cleanup
+     */
+    close() {
+        this.stopAutoSave();
+        if (this.dirty) {
+            this.saveSync();
+        }
+    }
+    // ============================================================================
+    // Helpers
+    // ============================================================================
+    createEmptyState() {
+        return {
+            version: '6.0',
+            created: new Date(),
+            lastModified: new Date(),
+            checksum: '',
+            memory: {
+                episodic: [],
+                semantic: [],
+                procedural: [],
+                stats: {
+                    totalEpisodes: 0,
+                    totalFacts: 0,
+                    totalSkills: 0,
+                },
+            },
+            conversation: {
+                history: [],
+                totalMessages: 0,
+                totalTokens: 0,
+            },
+            session: {
+                id: crypto.randomUUID(),
+                startTime: new Date(),
+                interactions: 0,
+                lastActivity: new Date(),
+            },
+            config: {
+                llm: {},
+                persistence: {},
+            },
+        };
+    }
+    mergeState(base, updates) {
+        return {
+            ...base,
+            ...updates,
+            memory: {
+                ...base.memory,
+                ...(updates.memory || {}),
+                stats: {
+                    ...base.memory.stats,
+                    ...(updates.memory?.stats || {}),
+                },
+            },
+            conversation: {
+                ...base.conversation,
+                ...(updates.conversation || {}),
+            },
+            session: {
+                ...base.session,
+                ...(updates.session || {}),
+            },
+            config: {
+                ...base.config,
+                ...(updates.config || {}),
+                llm: {
+                    ...base.config.llm,
+                    ...(updates.config?.llm || {}),
+                },
+                persistence: {
+                    ...base.config.persistence,
+                    ...(updates.config?.persistence || {}),
+                },
+            },
+        };
+    }
+    calculateChecksum(state) {
+        const data = JSON.stringify({
+            memory: state.memory,
+            conversation: state.conversation,
+        });
+        return crypto.createHash('sha256').update(data).digest('hex').slice(0, 16);
+    }
+    ensureDirectories() {
+        if (!fs.existsSync(this.dataDir)) {
+            fs.mkdirSync(this.dataDir, { recursive: true });
+        }
+        if (!fs.existsSync(this.backupDir)) {
+            fs.mkdirSync(this.backupDir, { recursive: true });
+        }
+    }
+    async cleanOldBackups() {
+        const maxBackups = this.options.maxBackups || 10;
+        const backups = this.listBackups();
+        if (backups.length > maxBackups) {
+            const toDelete = backups.slice(maxBackups);
+            for (const backup of toDelete) {
+                await fs.promises.unlink(path.join(this.backupDir, backup));
+            }
+        }
+    }
+    cleanOldBackupsSync() {
+        const maxBackups = this.options.maxBackups || 10;
+        const backups = this.listBackups();
+        if (backups.length > maxBackups) {
+            const toDelete = backups.slice(maxBackups);
+            for (const backup of toDelete) {
+                fs.unlinkSync(path.join(this.backupDir, backup));
+            }
+        }
+    }
+    /**
+     * Get data directory path
+     */
+    getDataDir() {
+        return this.dataDir;
+    }
+    /**
+     * Get stats
+     */
+    stats() {
+        const stateExists = fs.existsSync(this.statePath);
+        const stateSize = stateExists ? fs.statSync(this.statePath).size : 0;
+        return {
+            dataDir: this.dataDir,
+            stateExists,
+            stateSize,
+            backupCount: this.listBackups().length,
+            isDirty: this.dirty,
+            lastModified: this.state.lastModified,
+        };
+    }
+}
+exports.StateStore = StateStore;
+// ============================================================================
+// Factory & Singleton
+// ============================================================================
+let stateStoreInstance = null;
+function createStateStore(options) {
+    return new StateStore(options);
+}
+function getStateStore(options) {
+    if (!stateStoreInstance) {
+        stateStoreInstance = createStateStore(options);
+    }
+    return stateStoreInstance;
+}
+function resetStateStore() {
+    if (stateStoreInstance) {
+        stateStoreInstance.close();
+    }
+    stateStoreInstance = null;
+}
+const SESSIONS_DIR = 'sessions';
+class SessionManager {
+    dataDir;
+    sessionsDir;
+    options;
+    constructor(options = {}) {
+        this.options = options;
+        this.dataDir = options.dataDir || path.join(process.env.HOME || '.', '.genesis');
+        this.sessionsDir = path.join(this.dataDir, SESSIONS_DIR);
+        this.ensureDirectory();
+    }
+    /**
+     * List all saved sessions
+     */
+    listSessions() {
+        if (!fs.existsSync(this.sessionsDir)) {
+            return [];
+        }
+        const files = fs.readdirSync(this.sessionsDir)
+            .filter(f => f.endsWith('.json'))
+            .sort()
+            .reverse(); // Most recent first
+        const sessions = [];
+        for (const file of files) {
+            try {
+                const filePath = path.join(this.sessionsDir, file);
+                const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+                // Extract first user message as summary
+                const firstUserMsg = data.conversation?.history?.find(m => m.role === 'user');
+                const summary = firstUserMsg?.content?.slice(0, 80);
+                sessions.push({
+                    id: data.session?.id || file.replace('.json', ''),
+                    name: data.sessionName, // Optional session name
+                    created: new Date(data.created),
+                    lastModified: new Date(data.lastModified),
+                    messageCount: data.conversation?.totalMessages || 0,
+                    tokenCount: data.conversation?.totalTokens || 0,
+                    summary,
+                });
+            }
+            catch {
+                // Skip invalid files
+            }
+        }
+        return sessions;
+    }
+    /**
+     * Get the most recent session ID
+     */
+    getLastSessionId() {
+        const sessions = this.listSessions();
+        return sessions.length > 0 ? sessions[0].id : null;
+    }
+    /**
+     * Save current state as a session
+     */
+    saveSession(state, name) {
+        const sessionId = state.session.id;
+        const sessionPath = this.getSessionPath(sessionId);
+        const sessionData = {
+            ...state,
+            sessionName: name,
+        };
+        fs.writeFileSync(sessionPath, JSON.stringify(sessionData, null, 2));
+        // Cleanup old sessions if needed
+        this.cleanupOldSessions();
+        return sessionId;
+    }
+    /**
+     * Load a session by ID (or 'last' for most recent)
+     */
+    loadSession(sessionIdOrLast) {
+        let sessionId = sessionIdOrLast;
+        // Handle 'last' keyword
+        if (sessionIdOrLast === 'last') {
+            const lastId = this.getLastSessionId();
+            if (!lastId)
+                return null;
+            sessionId = lastId;
+        }
+        // Try exact match first
+        let sessionPath = this.getSessionPath(sessionId);
+        // If not found, try partial match (first 8 chars like git)
+        if (!fs.existsSync(sessionPath)) {
+            const sessions = this.listSessions();
+            const match = sessions.find(s => s.id.startsWith(sessionId));
+            if (match) {
+                sessionPath = this.getSessionPath(match.id);
+            }
+        }
+        if (!fs.existsSync(sessionPath)) {
+            return null;
+        }
+        try {
+            const data = JSON.parse(fs.readFileSync(sessionPath, 'utf-8'));
+            return data;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Fork a session (create a copy with new ID)
+     */
+    forkSession(sessionId, newName) {
+        const originalState = this.loadSession(sessionId);
+        if (!originalState)
+            return null;
+        // Create new session with new ID
+        const forkedState = {
+            ...originalState,
+            session: {
+                ...originalState.session,
+                id: crypto.randomUUID(),
+                startTime: new Date(),
+            },
+            created: new Date(),
+            lastModified: new Date(),
+        };
+        return this.saveSession(forkedState, newName || `Fork of ${sessionId.slice(0, 8)}`);
+    }
+    /**
+     * Delete a session
+     */
+    deleteSession(sessionId) {
+        const sessionPath = this.getSessionPath(sessionId);
+        if (!fs.existsSync(sessionPath)) {
+            // Try partial match
+            const sessions = this.listSessions();
+            const match = sessions.find(s => s.id.startsWith(sessionId));
+            if (match) {
+                fs.unlinkSync(this.getSessionPath(match.id));
+                return true;
+            }
+            return false;
+        }
+        fs.unlinkSync(sessionPath);
+        return true;
+    }
+    /**
+     * Rename a session
+     */
+    renameSession(sessionId, newName) {
+        const state = this.loadSession(sessionId);
+        if (!state)
+            return false;
+        this.saveSession(state, newName);
+        return true;
+    }
+    getSessionPath(sessionId) {
+        return path.join(this.sessionsDir, `${sessionId}.json`);
+    }
+    ensureDirectory() {
+        if (!fs.existsSync(this.sessionsDir)) {
+            fs.mkdirSync(this.sessionsDir, { recursive: true });
+        }
+    }
+    cleanupOldSessions() {
+        const maxSessions = this.options.maxSessions || 50;
+        const sessions = this.listSessions();
+        if (sessions.length > maxSessions) {
+            // Delete oldest sessions
+            const toDelete = sessions.slice(maxSessions);
+            for (const session of toDelete) {
+                this.deleteSession(session.id);
+            }
+        }
+    }
+}
+exports.SessionManager = SessionManager;
+// Singleton
+let sessionManagerInstance = null;
+function getSessionManager(options) {
+    if (!sessionManagerInstance) {
+        sessionManagerInstance = new SessionManager(options);
+    }
+    return sessionManagerInstance;
+}