dartmind 17.0.0

package/dist/v10/brain/BrainSession.js

@@ -0,0 +1,729 @@
+/**
+ * FlutterAI v10 - BrainSession
+ *
+ * Coordinated Brain+Mask workflow management.
+ *
+ * Provides a unified interface for:
+ * - Processing requests through Brain and formatting via Mask
+ * - Session state management and persistence
+ * - Event system for monitoring
+ * - Metrics tracking
+ * - History management
+ * - Checkpoint/Undo/Redo support (v10 Enhanced)
+ * - File change tracking (v10 Enhanced)
+ * - Session persistence to disk (v10 Enhanced)
+ *
+ * @module v10/brain/BrainSession
+ */
+import { nanoid } from 'nanoid';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { Brain } from './Brain.js';
+import { Mask } from './Mask.js';
+import { getCheckpointManager } from '../../state/CheckpointManager.js';
+import { getUndoStack } from '../../state/UndoStack.js';
+import { getFileTracker } from '../../state/FileTracker.js';
+// ============================================================================
+// Default Config
+// ============================================================================
+const DEFAULT_CONFIG = {
+    name: 'default',
+    autoSave: false,
+    saveInterval: 30000,
+    maxHistory: 1000,
+    // v10 Enhanced defaults
+    enableCheckpoints: true,
+    enableUndo: true,
+    enableFileTracking: true,
+    persistDir: '.flutterai/sessions',
+    autoCheckpoint: true
+};
+// ============================================================================
+// BrainSession Implementation
+// ============================================================================
+export class BrainSession {
+    id;
+    brain;
+    mask;
+    config;
+    history = [];
+    context = {};
+    eventHandlers = new Map();
+    metrics;
+    // v10 Enhanced state management
+    checkpointManager = null;
+    undoStack = null;
+    fileTracker = null;
+    currentCheckpointId = null;
+    currentGroupId = null;
+    autoSaveTimer = null;
+    lastSaved = null;
+    constructor(options = {}) {
+        this.id = nanoid();
+        this.brain = options.brain || new Brain();
+        this.mask = options.mask || new Mask();
+        this.config = { ...DEFAULT_CONFIG, ...options.config };
+        this.metrics = this.createEmptyMetrics();
+        // Initialize event handler sets
+        const eventTypes = [
+            'process', 'plan', 'decide', 'error', 'reset',
+            // v10 Enhanced event types
+            'checkpoint:created', 'checkpoint:restored', 'undo', 'redo',
+            'file:changed', 'session:saved', 'session:loaded'
+        ];
+        for (const type of eventTypes) {
+            this.eventHandlers.set(type, new Set());
+        }
+        // v10 Enhanced: Initialize state managers
+        if (this.config.enableCheckpoints) {
+            this.checkpointManager = getCheckpointManager();
+        }
+        if (this.config.enableUndo) {
+            this.undoStack = getUndoStack();
+        }
+        if (this.config.enableFileTracking) {
+            this.fileTracker = getFileTracker();
+        }
+        // v10 Enhanced: Start auto-save timer if enabled
+        if (this.config.autoSave && this.config.saveInterval > 0) {
+            this.startAutoSave();
+        }
+    }
+    // --------------------------------------------------------------------------
+    // Accessor Methods
+    // --------------------------------------------------------------------------
+    /**
+     * Get session ID
+     */
+    getId() {
+        return this.id;
+    }
+    /**
+     * Get Brain instance
+     */
+    getBrain() {
+        return this.brain;
+    }
+    /**
+     * Get Mask instance
+     */
+    getMask() {
+        return this.mask;
+    }
+    /**
+     * Get session config
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    // --------------------------------------------------------------------------
+    // Processing Methods
+    // --------------------------------------------------------------------------
+    /**
+     * Process a request through Brain and format via Mask
+     */
+    async process(request) {
+        const startTime = Date.now();
+        try {
+            // Think with Brain
+            const thought = await this.brain.think(request, {
+                context: this.context
+            });
+            // Format with Mask
+            const output = this.mask.formatThought(thought);
+            // Record history
+            const entry = this.createHistoryEntry('process', request, output, Date.now() - startTime);
+            this.addHistoryEntry(entry);
+            // Update metrics
+            this.updateMetrics(thought);
+            // Emit event
+            this.emit('process', { thought, output });
+            return output;
+        }
+        catch (error) {
+            this.emit('error', { error, request });
+            throw error;
+        }
+    }
+    /**
+     * Create and format a plan
+     */
+    async plan(request) {
+        const startTime = Date.now();
+        try {
+            const plan = await this.brain.plan(request);
+            const output = this.mask.formatPlan(plan);
+            const entry = this.createHistoryEntry('plan', request, output, Date.now() - startTime);
+            this.addHistoryEntry(entry);
+            this.metrics.planCount++;
+            this.metrics.totalProcessingTime += entry.duration;
+            this.metrics.requestCount++;
+            this.emit('plan', { plan, output });
+            return output;
+        }
+        catch (error) {
+            this.emit('error', { error, request });
+            throw error;
+        }
+    }
+    /**
+     * Make and format a decision
+     */
+    async decide(question, options = {}) {
+        const startTime = Date.now();
+        try {
+            const decision = await this.brain.decide(question, options);
+            // Format decision output
+            let output;
+            if (decision.answer !== undefined) {
+                output = `Decision: ${decision.answer ? 'Yes' : 'No'}\nReasoning: ${decision.reasoning}\nConfidence: ${decision.confidence}`;
+            }
+            else {
+                output = `Choice: ${decision.choice}\nReasoning: ${decision.reasoning}\nConfidence: ${decision.confidence}`;
+            }
+            const entry = this.createHistoryEntry('decide', question, output, Date.now() - startTime);
+            this.addHistoryEntry(entry);
+            this.metrics.decisionCount++;
+            this.metrics.totalProcessingTime += entry.duration;
+            this.metrics.requestCount++;
+            this.emit('decide', { decision, output });
+            return output;
+        }
+        catch (error) {
+            this.emit('error', { error, question });
+            throw error;
+        }
+    }
+    // --------------------------------------------------------------------------
+    // Context Methods
+    // --------------------------------------------------------------------------
+    /**
+     * Set a context value
+     */
+    setContext(key, value) {
+        this.context[key] = value;
+        this.brain.setContext(key, value);
+    }
+    /**
+     * Get a context value
+     */
+    getContext(key) {
+        return this.context[key];
+    }
+    /**
+     * Set multiple context values
+     */
+    setContextBulk(values) {
+        for (const [key, value] of Object.entries(values)) {
+            this.setContext(key, value);
+        }
+    }
+    /**
+     * Clear all context
+     */
+    clearContext() {
+        this.context = {};
+        this.brain.clearContext();
+    }
+    // --------------------------------------------------------------------------
+    // State Management Methods
+    // --------------------------------------------------------------------------
+    /**
+     * Export session state
+     */
+    exportState() {
+        return {
+            id: this.id,
+            brainState: this.brain.exportState(),
+            history: [...this.history],
+            context: { ...this.context },
+            config: { ...this.config },
+            metrics: { ...this.metrics }
+        };
+    }
+    /**
+     * Import session state
+     */
+    importState(state) {
+        this.brain.importState(state.brainState);
+        this.history = [...state.history];
+        this.context = { ...state.context };
+        this.metrics = { ...state.metrics };
+    }
+    /**
+     * Reset session to initial state
+     */
+    reset() {
+        this.brain.reset();
+        this.history = [];
+        this.context = {};
+        this.metrics = this.createEmptyMetrics();
+        // Keep the same ID
+        this.emit('reset', {});
+    }
+    // --------------------------------------------------------------------------
+    // Event Methods
+    // --------------------------------------------------------------------------
+    /**
+     * Register event handler
+     */
+    on(event, handler) {
+        const handlers = this.eventHandlers.get(event);
+        if (handlers) {
+            handlers.add(handler);
+        }
+    }
+    /**
+     * Remove event handler
+     */
+    off(event, handler) {
+        const handlers = this.eventHandlers.get(event);
+        if (handlers) {
+            handlers.delete(handler);
+        }
+    }
+    /**
+     * Emit an event
+     */
+    emit(type, data) {
+        const event = {
+            type,
+            timestamp: new Date(),
+            data
+        };
+        const handlers = this.eventHandlers.get(type);
+        if (handlers) {
+            for (const handler of handlers) {
+                try {
+                    handler(event);
+                }
+                catch (e) {
+                    // Don't let handler errors break the flow
+                    console.error('Event handler error:', e);
+                }
+            }
+        }
+    }
+    // --------------------------------------------------------------------------
+    // Metrics Methods
+    // --------------------------------------------------------------------------
+    /**
+     * Get session metrics
+     */
+    getMetrics() {
+        return { ...this.metrics };
+    }
+    // --------------------------------------------------------------------------
+    // History Methods
+    // --------------------------------------------------------------------------
+    /**
+     * Get processing history
+     */
+    getHistory(type) {
+        if (type) {
+            return this.history.filter(entry => entry.type === type);
+        }
+        return [...this.history];
+    }
+    /**
+     * Clear history
+     */
+    clearHistory() {
+        this.history = [];
+    }
+    // --------------------------------------------------------------------------
+    // Persona/Format Methods
+    // --------------------------------------------------------------------------
+    /**
+     * Set Mask persona
+     */
+    setPersona(persona) {
+        this.mask.setPersona(persona);
+    }
+    /**
+     * Set output format
+     */
+    setFormat(format) {
+        // Create new mask with updated format
+        const currentConfig = this.mask.getConfig();
+        this.mask = new Mask({ ...currentConfig, format });
+    }
+    // --------------------------------------------------------------------------
+    // v10 Enhanced: Checkpoint Methods
+    // --------------------------------------------------------------------------
+    /**
+     * Create a checkpoint for specified files
+     */
+    async createCheckpoint(name, filePaths, description = '') {
+        if (!this.checkpointManager) {
+            return null;
+        }
+        const checkpoint = await this.checkpointManager.createCheckpoint(name, filePaths, description, {
+            sessionId: this.id,
+            brainState: this.brain.exportState(),
+            timestamp: Date.now()
+        });
+        this.currentCheckpointId = checkpoint.id;
+        this.emit('checkpoint:created', { checkpoint });
+        return checkpoint;
+    }
+    /**
+     * Quick checkpoint before a risky operation
+     */
+    async quickCheckpoint(filePaths, reason = 'auto') {
+        if (!this.checkpointManager) {
+            return null;
+        }
+        const checkpoint = await this.checkpointManager.quickCheckpoint(filePaths, reason);
+        this.currentCheckpointId = checkpoint.id;
+        this.emit('checkpoint:created', { checkpoint, quick: true });
+        return checkpoint;
+    }
+    /**
+     * Restore files from a checkpoint
+     */
+    async restoreCheckpoint(checkpointId) {
+        if (!this.checkpointManager) {
+            return null;
+        }
+        const targetId = checkpointId || this.currentCheckpointId;
+        if (!targetId) {
+            throw new Error('No checkpoint ID provided and no current checkpoint');
+        }
+        const result = await this.checkpointManager.restoreCheckpoint(targetId);
+        this.emit('checkpoint:restored', { checkpointId: targetId, ...result });
+        return result;
+    }
+    /**
+     * Get current checkpoint ID
+     */
+    getCurrentCheckpointId() {
+        return this.currentCheckpointId;
+    }
+    /**
+     * Get recent checkpoints
+     */
+    getRecentCheckpoints(limit = 10) {
+        return this.checkpointManager?.getRecentCheckpoints(limit) || [];
+    }
+    /**
+     * Get files changed since last checkpoint
+     */
+    async getChangedFilesSinceCheckpoint() {
+        if (!this.checkpointManager || !this.currentCheckpointId) {
+            return [];
+        }
+        return this.checkpointManager.getChangedFiles(this.currentCheckpointId);
+    }
+    // --------------------------------------------------------------------------
+    // v10 Enhanced: Undo/Redo Methods
+    // --------------------------------------------------------------------------
+    /**
+     * Start a group of related file operations
+     */
+    startOperationGroup(name) {
+        if (!this.undoStack) {
+            return null;
+        }
+        this.currentGroupId = this.undoStack.startGroup(name);
+        return this.currentGroupId;
+    }
+    /**
+     * End the current operation group
+     */
+    endOperationGroup() {
+        if (!this.undoStack) {
+            return null;
+        }
+        const group = this.undoStack.endGroup();
+        this.currentGroupId = null;
+        return group;
+    }
+    /**
+     * Record a file modification for undo support
+     */
+    async recordFileModify(filePath, oldContent, newContent) {
+        if (!this.undoStack) {
+            return null;
+        }
+        return this.undoStack.recordModify(filePath, oldContent, newContent, this.currentGroupId || undefined);
+    }
+    /**
+     * Record a file creation for undo support
+     */
+    async recordFileCreate(filePath, content) {
+        if (!this.undoStack) {
+            return null;
+        }
+        return this.undoStack.recordCreate(filePath, content, this.currentGroupId || undefined);
+    }
+    /**
+     * Record a file deletion for undo support
+     */
+    async recordFileDelete(filePath, oldContent) {
+        if (!this.undoStack) {
+            return null;
+        }
+        return this.undoStack.recordDelete(filePath, oldContent, this.currentGroupId || undefined);
+    }
+    /**
+     * Undo the last file operation
+     */
+    async undo() {
+        if (!this.undoStack) {
+            return null;
+        }
+        const operation = await this.undoStack.undo();
+        if (operation) {
+            this.emit('undo', { operation });
+        }
+        return operation;
+    }
+    /**
+     * Redo the last undone operation
+     */
+    async redo() {
+        if (!this.undoStack) {
+            return null;
+        }
+        const operation = await this.undoStack.redo();
+        if (operation) {
+            this.emit('redo', { operation });
+        }
+        return operation;
+    }
+    /**
+     * Undo all operations in a group
+     */
+    async undoGroup(groupId) {
+        if (!this.undoStack) {
+            return [];
+        }
+        const operations = await this.undoStack.undoGroup(groupId);
+        this.emit('undo', { operations, groupId });
+        return operations;
+    }
+    /**
+     * Check if undo is available
+     */
+    canUndo() {
+        return this.undoStack?.canUndo() ?? false;
+    }
+    /**
+     * Check if redo is available
+     */
+    canRedo() {
+        return this.undoStack?.canRedo() ?? false;
+    }
+    /**
+     * Get recent file operations
+     */
+    getRecentOperations(limit = 10) {
+        return this.undoStack?.getRecentOperations(limit) || [];
+    }
+    // --------------------------------------------------------------------------
+    // v10 Enhanced: File Tracking Methods
+    // --------------------------------------------------------------------------
+    /**
+     * Track a file read
+     */
+    async trackFileRead(filePath) {
+        if (!this.fileTracker) {
+            return null;
+        }
+        const tracked = await this.fileTracker.trackRead(filePath);
+        return tracked;
+    }
+    /**
+     * Track a file write
+     */
+    async trackFileWrite(filePath, content, isNew = false) {
+        if (!this.fileTracker) {
+            return null;
+        }
+        const tracked = await this.fileTracker.trackWrite(filePath, content, isNew);
+        this.emit('file:changed', { file: tracked, operation: isNew ? 'create' : 'write' });
+        return tracked;
+    }
+    /**
+     * Get all tracked files modified in this session
+     */
+    getModifiedFiles() {
+        return this.fileTracker?.getModifiedFiles() || [];
+    }
+    /**
+     * Get files with external modifications
+     */
+    getExternallyModifiedFiles() {
+        return this.fileTracker?.getExternallyModifiedFiles() || [];
+    }
+    /**
+     * Check for external changes on a file
+     */
+    async checkForExternalChanges(filePath) {
+        return this.fileTracker?.checkForExternalChanges(filePath) ?? false;
+    }
+    /**
+     * Get file tracking stats
+     */
+    getFileTrackingStats() {
+        return this.fileTracker?.getStats() ?? null;
+    }
+    // --------------------------------------------------------------------------
+    // v10 Enhanced: Persistence Methods
+    // --------------------------------------------------------------------------
+    /**
+     * Save session state to disk
+     */
+    async saveSession(filePath) {
+        const targetPath = filePath || path.join(this.config.persistDir, `session-${this.id}.json`);
+        // Ensure directory exists
+        await fs.mkdir(path.dirname(targetPath), { recursive: true });
+        const state = this.exportState();
+        // Add v10 enhanced state info
+        const enhancedState = {
+            ...state,
+            currentCheckpointId: this.currentCheckpointId ?? undefined,
+            trackedFiles: this.fileTracker?.getAllTrackedFiles().map(f => f.path) || [],
+            undoStackSize: this.undoStack?.getUndoCount() || 0,
+            redoStackSize: this.undoStack?.getRedoCount() || 0,
+            persistPath: targetPath,
+            lastSaved: Date.now()
+        };
+        await fs.writeFile(targetPath, JSON.stringify(enhancedState, null, 2), 'utf-8');
+        this.lastSaved = Date.now();
+        this.emit('session:saved', { path: targetPath, timestamp: this.lastSaved });
+        return targetPath;
+    }
+    /**
+     * Load session state from disk
+     */
+    async loadSession(filePath) {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const state = JSON.parse(content);
+        this.importState(state);
+        // Restore v10 enhanced state
+        if (state.currentCheckpointId) {
+            this.currentCheckpointId = state.currentCheckpointId;
+        }
+        this.emit('session:loaded', { path: filePath, state });
+    }
+    /**
+     * Get last save timestamp
+     */
+    getLastSaved() {
+        return this.lastSaved;
+    }
+    /**
+     * Check if session has unsaved changes
+     */
+    hasUnsavedChanges() {
+        if (!this.lastSaved) {
+            return this.history.length > 0;
+        }
+        // Check if any history entry is newer than last save
+        return this.history.some(entry => entry.timestamp.getTime() > this.lastSaved);
+    }
+    // --------------------------------------------------------------------------
+    // v10 Enhanced: Lifecycle Methods
+    // --------------------------------------------------------------------------
+    /**
+     * Clean up session resources
+     */
+    async dispose() {
+        // Stop auto-save timer
+        if (this.autoSaveTimer) {
+            clearInterval(this.autoSaveTimer);
+            this.autoSaveTimer = null;
+        }
+        // Save if there are unsaved changes
+        if (this.config.autoSave && this.hasUnsavedChanges()) {
+            try {
+                await this.saveSession();
+            }
+            catch (e) {
+                console.error('Failed to save session on dispose:', e);
+            }
+        }
+        // Clear event handlers
+        for (const handlers of this.eventHandlers.values()) {
+            handlers.clear();
+        }
+    }
+    /**
+     * Start auto-save timer
+     */
+    startAutoSave() {
+        if (this.autoSaveTimer) {
+            clearInterval(this.autoSaveTimer);
+        }
+        this.autoSaveTimer = setInterval(async () => {
+            if (this.hasUnsavedChanges()) {
+                try {
+                    await this.saveSession();
+                }
+                catch (e) {
+                    console.error('Auto-save failed:', e);
+                }
+            }
+        }, this.config.saveInterval);
+    }
+    // --------------------------------------------------------------------------
+    // Private Methods
+    // --------------------------------------------------------------------------
+    /**
+     * Create empty metrics object
+     */
+    createEmptyMetrics() {
+        return {
+            requestCount: 0,
+            totalProcessingTime: 0,
+            averageConfidence: 0,
+            thoughtCount: 0,
+            planCount: 0,
+            decisionCount: 0
+        };
+    }
+    /**
+     * Create a history entry
+     */
+    createHistoryEntry(type, request, response, duration) {
+        return {
+            id: nanoid(),
+            type,
+            request,
+            response,
+            timestamp: new Date(),
+            duration
+        };
+    }
+    /**
+     * Add entry to history (with limit enforcement)
+     */
+    addHistoryEntry(entry) {
+        this.history.push(entry);
+        // Enforce maxHistory limit
+        while (this.history.length > this.config.maxHistory) {
+            this.history.shift();
+        }
+    }
+    /**
+     * Update metrics from a thought
+     */
+    updateMetrics(thought) {
+        this.metrics.requestCount++;
+        this.metrics.thoughtCount++;
+        this.metrics.totalProcessingTime += 0; // Updated by history entry
+        // Update average confidence
+        const thoughts = this.brain.getThoughts();
+        if (thoughts.length > 0) {
+            const totalConfidence = thoughts.reduce((sum, t) => sum + t.confidence, 0);
+            this.metrics.averageConfidence = totalConfidence / thoughts.length;
+        }
+    }
+}
+// ============================================================================
+// Export
+// ============================================================================
+export default BrainSession;
+//# sourceMappingURL=BrainSession.js.map