@wundr.io/cli 1.0.0

package/dist/context/session-manager.js

@@ -0,0 +1,682 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = void 0;
+const tslib_1 = require("tslib");
+const events_1 = require("events");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const logger_1 = require("../utils/logger");
+/**
+ * Session manager for persistent context, user preferences, and workspace management
+ */
+class SessionManager extends events_1.EventEmitter {
+    config;
+    conversationManager;
+    commandMapper;
+    activeSessions;
+    workspaces;
+    currentSessionId;
+    backupTimer;
+    cleanupTimer;
+    constructor(conversationManager, commandMapper, config = {}) {
+        super();
+        this.conversationManager = conversationManager;
+        this.commandMapper = commandMapper;
+        this.config = {
+            persistencePath: path_1.default.join(process.cwd(), '.wundr', 'sessions'),
+            sessionTimeout: 24 * 60, // 24 hours
+            maxSessions: 10,
+            autoDetectProjects: true,
+            enableContextLearning: true,
+            backupInterval: 15, // 15 minutes
+            ...config,
+        };
+        this.activeSessions = new Map();
+        this.workspaces = new Map();
+        this.initialize();
+    }
+    /**
+     * Create or resume a session
+     */
+    async createSession(userId, workspacePath, sessionId) {
+        const id = sessionId ||
+            `session_${userId}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        // Check if session already exists
+        if (this.activeSessions.has(id)) {
+            await this.resumeSession(id);
+            return id;
+        }
+        const workspace = workspacePath || process.cwd();
+        const projectContext = await this.detectProjectContext(workspace);
+        const session = {
+            id,
+            userId,
+            currentWorkspace: workspace,
+            recentCommands: [],
+            contextStack: [],
+            userPreferences: await this.loadUserPreferences(userId),
+            projectContext,
+            temporaryData: {},
+            created: new Date(),
+            lastAccessed: new Date(),
+        };
+        // Load workspace if it exists
+        const workspaceConfig = await this.loadWorkspace(workspace);
+        if (workspaceConfig) {
+            workspaceConfig.lastAccessed = new Date();
+            this.workspaces.set(workspace, workspaceConfig);
+        }
+        this.activeSessions.set(id, session);
+        this.currentSessionId = id;
+        await this.persistSession(session);
+        this.emit('session_created', { sessionId: id, userId, workspace });
+        logger_1.logger.debug(`Created session: ${id} for user: ${userId}`);
+        return id;
+    }
+    /**
+     * Resume an existing session
+     */
+    async resumeSession(sessionId) {
+        let session = this.activeSessions.get(sessionId);
+        if (!session) {
+            // Try to load from persistence
+            session = (await this.loadSession(sessionId)) || undefined;
+            if (!session) {
+                throw new Error(`Session not found: ${sessionId}`);
+            }
+        }
+        session.lastAccessed = new Date();
+        this.currentSessionId = sessionId;
+        this.activeSessions.set(sessionId, session);
+        // Refresh project context
+        if (session.projectContext) {
+            session.projectContext = await this.detectProjectContext(session.currentWorkspace);
+        }
+        await this.persistSession(session);
+        this.emit('session_resumed', { sessionId, session });
+        logger_1.logger.debug(`Resumed session: ${sessionId}`);
+        return session;
+    }
+    /**
+     * Get current session
+     */
+    getCurrentSession() {
+        if (!this.currentSessionId)
+            return null;
+        return this.activeSessions.get(this.currentSessionId) || null;
+    }
+    /**
+     * Get session by ID
+     */
+    getSession(sessionId) {
+        return this.activeSessions.get(sessionId) || null;
+    }
+    /**
+     * Update session context
+     */
+    async updateSessionContext(sessionId, contextType, contextData) {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        // Add to context stack
+        session.contextStack.push({
+            type: contextType,
+            context: contextData,
+            timestamp: new Date(),
+        });
+        // Limit context stack size
+        if (session.contextStack.length > 50) {
+            session.contextStack = session.contextStack.slice(-25);
+        }
+        // Update specific context based on type
+        switch (contextType) {
+            case 'project':
+                session.projectContext = { ...session.projectContext, ...contextData };
+                break;
+            case 'conversation':
+                session.activeConversation = contextData.conversationId;
+                break;
+        }
+        session.lastAccessed = new Date();
+        await this.persistSession(session);
+        this.emit('context_updated', { sessionId, contextType, contextData });
+    }
+    /**
+     * Add command to session history
+     */
+    async addCommandToHistory(sessionId, command, success, duration) {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        session.recentCommands.push({
+            command,
+            timestamp: new Date(),
+            success,
+            duration,
+        });
+        // Limit history size
+        const maxHistory = session.userPreferences.maxHistoryLength || 100;
+        if (session.recentCommands.length > maxHistory) {
+            session.recentCommands = session.recentCommands.slice(-maxHistory / 2);
+        }
+        session.lastAccessed = new Date();
+        await this.persistSession(session);
+        // Learn from command patterns if enabled
+        if (this.config.enableContextLearning) {
+            await this.analyzeCommandPatterns(session);
+        }
+        this.emit('command_recorded', { sessionId, command, success, duration });
+    }
+    /**
+     * Update user preferences
+     */
+    async updateUserPreferences(userId, preferences) {
+        const defaultPreferences = this.getDefaultPreferences();
+        const currentPreferences = await this.loadUserPreferences(userId);
+        const updatedPreferences = { ...currentPreferences, ...preferences };
+        await this.saveUserPreferences(userId, updatedPreferences);
+        // Update all active sessions for this user
+        for (const [sessionId, session] of this.activeSessions) {
+            if (session.userId === userId) {
+                session.userPreferences = updatedPreferences;
+                await this.persistSession(session);
+            }
+        }
+        this.emit('preferences_updated', {
+            userId,
+            preferences: updatedPreferences,
+        });
+        logger_1.logger.debug(`Updated preferences for user: ${userId}`);
+    }
+    /**
+     * Register a workspace
+     */
+    async registerWorkspace(workspacePath, config) {
+        const workspace = {
+            name: config.name || path_1.default.basename(workspacePath),
+            path: workspacePath,
+            type: config.type || 'unknown',
+            settings: config.settings || {},
+            lastAccessed: new Date(),
+            bookmarked: config.bookmarked || false,
+        };
+        this.workspaces.set(workspacePath, workspace);
+        await this.saveWorkspace(workspace);
+        this.emit('workspace_registered', { workspace });
+        logger_1.logger.debug(`Registered workspace: ${workspacePath}`);
+    }
+    /**
+     * Get workspace suggestions based on recent activity
+     */
+    getWorkspaceSuggestions(limit = 5) {
+        const workspaces = Array.from(this.workspaces.values()).sort((a, b) => b.lastAccessed.getTime() - a.lastAccessed.getTime());
+        return workspaces.slice(0, limit);
+    }
+    /**
+     * Search session history
+     */
+    searchHistory(sessionId, query) {
+        const session = this.activeSessions.get(sessionId);
+        if (!session)
+            return [];
+        let history = session.recentCommands;
+        if (query.command) {
+            const searchTerm = query.command.toLowerCase();
+            history = history.filter(cmd => cmd.command.toLowerCase().includes(searchTerm));
+        }
+        if (query.timeRange) {
+            history = history.filter(cmd => cmd.timestamp >= query.timeRange.from &&
+                cmd.timestamp <= query.timeRange.to);
+        }
+        if (query.successOnly) {
+            history = history.filter(cmd => cmd.success);
+        }
+        if (query.limit) {
+            history = history.slice(-query.limit);
+        }
+        return history;
+    }
+    /**
+     * Get contextual suggestions based on current session
+     */
+    async getContextualSuggestions(sessionId, limit = 5) {
+        const session = this.activeSessions.get(sessionId);
+        if (!session)
+            return [];
+        const suggestions = [];
+        // Command suggestions based on recent history
+        const recentCommands = session.recentCommands
+            .filter(cmd => cmd.success)
+            .slice(-10);
+        const commandFrequency = new Map();
+        for (const cmd of recentCommands) {
+            const baseCommand = cmd.command.split(' ')[0];
+            if (baseCommand) {
+                commandFrequency.set(baseCommand, (commandFrequency.get(baseCommand) || 0) + 1);
+            }
+        }
+        for (const [command, frequency] of commandFrequency) {
+            suggestions.push({
+                type: 'command',
+                suggestion: command,
+                description: `Recently used command (${frequency} times)`,
+                confidence: Math.min(0.9, frequency * 0.2),
+            });
+        }
+        // Workspace suggestions
+        const workspaceSuggestions = this.getWorkspaceSuggestions(3);
+        for (const workspace of workspaceSuggestions) {
+            if (workspace.path !== session.currentWorkspace) {
+                suggestions.push({
+                    type: 'workspace',
+                    suggestion: workspace.path,
+                    description: `Switch to ${workspace.name}`,
+                    confidence: 0.6,
+                });
+            }
+        }
+        // Sort by confidence and limit
+        suggestions.sort((a, b) => b.confidence - a.confidence);
+        return suggestions.slice(0, limit);
+    }
+    /**
+     * Export session data
+     */
+    async exportSession(sessionId, format) {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        switch (format) {
+            case 'json':
+                return JSON.stringify(session, null, 2);
+            case 'csv':
+                return this.sessionToCsv(session);
+            default:
+                throw new Error(`Unsupported export format: ${format}`);
+        }
+    }
+    /**
+     * Clean up expired sessions
+     */
+    async cleanupSessions() {
+        const now = new Date();
+        const timeoutMs = this.config.sessionTimeout * 60 * 1000;
+        const expiredSessions = [];
+        for (const [sessionId, session] of this.activeSessions) {
+            const timeSinceAccess = now.getTime() - session.lastAccessed.getTime();
+            if (timeSinceAccess > timeoutMs) {
+                expiredSessions.push(sessionId);
+            }
+        }
+        for (const sessionId of expiredSessions) {
+            const session = this.activeSessions.get(sessionId);
+            // Final persist before cleanup
+            await this.persistSession(session);
+            this.activeSessions.delete(sessionId);
+            this.emit('session_expired', { sessionId });
+        }
+        // Limit active sessions
+        if (this.activeSessions.size > this.config.maxSessions) {
+            const sessionsByAccess = Array.from(this.activeSessions.entries()).sort(([, a], [, b]) => a.lastAccessed.getTime() - b.lastAccessed.getTime());
+            const excessCount = this.activeSessions.size - this.config.maxSessions;
+            const toRemove = sessionsByAccess.slice(0, excessCount);
+            for (const [sessionId, session] of toRemove) {
+                await this.persistSession(session);
+                this.activeSessions.delete(sessionId);
+                this.emit('session_archived', { sessionId });
+            }
+        }
+        if (expiredSessions.length > 0) {
+            logger_1.logger.debug(`Cleaned up ${expiredSessions.length} expired sessions`);
+        }
+    }
+    /**
+     * Get session statistics
+     */
+    getSessionStats() {
+        const activeSessions = this.activeSessions.size;
+        const totalCommands = Array.from(this.activeSessions.values()).reduce((sum, session) => sum + session.recentCommands.length, 0);
+        const sessionDurations = Array.from(this.activeSessions.values()).map(session => session.lastAccessed.getTime() - session.created.getTime());
+        const averageSessionDuration = sessionDurations.length > 0
+            ? sessionDurations.reduce((sum, duration) => sum + duration, 0) /
+                sessionDurations.length
+            : 0;
+        // Command frequency analysis
+        const commandCounts = new Map();
+        for (const session of this.activeSessions.values()) {
+            for (const cmd of session.recentCommands) {
+                const baseCommand = cmd.command.split(' ')[0];
+                if (baseCommand) {
+                    commandCounts.set(baseCommand, (commandCounts.get(baseCommand) || 0) + 1);
+                }
+            }
+        }
+        const mostUsedCommands = Array.from(commandCounts.entries())
+            .map(([command, count]) => ({ command, count }))
+            .sort((a, b) => b.count - a.count)
+            .slice(0, 10);
+        return {
+            activeSessions,
+            totalCommands,
+            averageSessionDuration,
+            mostUsedCommands,
+            workspaceCount: this.workspaces.size,
+        };
+    }
+    // Private methods
+    async initialize() {
+        // Ensure directories exist
+        await fs_extra_1.default.ensureDir(this.config.persistencePath);
+        await fs_extra_1.default.ensureDir(path_1.default.join(this.config.persistencePath, 'users'));
+        await fs_extra_1.default.ensureDir(path_1.default.join(this.config.persistencePath, 'workspaces'));
+        // Load existing workspaces
+        await this.loadAllWorkspaces();
+        // Start background tasks
+        this.startBackgroundTasks();
+        logger_1.logger.debug('Session manager initialized');
+    }
+    startBackgroundTasks() {
+        // Periodic backup
+        this.backupTimer = setInterval(async () => {
+            try {
+                await this.backupActiveSessions();
+            }
+            catch (error) {
+                logger_1.logger.error('Session backup failed:', error);
+            }
+        }, this.config.backupInterval * 60 * 1000);
+        // Periodic cleanup
+        this.cleanupTimer = setInterval(async () => {
+            try {
+                await this.cleanupSessions();
+            }
+            catch (error) {
+                logger_1.logger.error('Session cleanup failed:', error);
+            }
+        }, 30 * 60 * 1000); // Every 30 minutes
+    }
+    async detectProjectContext(workspacePath) {
+        if (!this.config.autoDetectProjects)
+            return undefined;
+        try {
+            const context = {
+                rootPath: workspacePath,
+                projectType: 'unknown',
+                packageManager: 'unknown',
+                dependencies: [],
+                devDependencies: [],
+                scripts: {},
+            };
+            // Detect project type and package manager
+            const packageJsonPath = path_1.default.join(workspacePath, 'package.json');
+            if (await fs_extra_1.default.pathExists(packageJsonPath)) {
+                const packageJson = await fs_extra_1.default.readJson(packageJsonPath);
+                context.dependencies = Object.keys(packageJson.dependencies || {});
+                context.devDependencies = Object.keys(packageJson.devDependencies || {});
+                context.scripts = packageJson.scripts || {};
+                // Detect project type from dependencies
+                if (context.dependencies.includes('react')) {
+                    context.projectType = 'react';
+                }
+                else if (context.dependencies.includes('vue')) {
+                    context.projectType = 'vue';
+                }
+                else if (context.dependencies.includes('@angular/core')) {
+                    context.projectType = 'angular';
+                }
+                else {
+                    context.projectType = 'nodejs';
+                }
+                // Detect package manager
+                if (await fs_extra_1.default.pathExists(path_1.default.join(workspacePath, 'pnpm-lock.yaml'))) {
+                    context.packageManager = 'pnpm';
+                }
+                else if (await fs_extra_1.default.pathExists(path_1.default.join(workspacePath, 'yarn.lock'))) {
+                    context.packageManager = 'yarn';
+                }
+                else if (await fs_extra_1.default.pathExists(path_1.default.join(workspacePath, 'package-lock.json'))) {
+                    context.packageManager = 'npm';
+                }
+            }
+            // Detect other project types
+            if (await fs_extra_1.default.pathExists(path_1.default.join(workspacePath, 'requirements.txt'))) {
+                context.projectType = 'python';
+                context.packageManager = 'pip';
+            }
+            else if (await fs_extra_1.default.pathExists(path_1.default.join(workspacePath, 'pom.xml'))) {
+                context.projectType = 'java';
+                context.packageManager = 'maven';
+            }
+            else if (await fs_extra_1.default.pathExists(path_1.default.join(workspacePath, 'build.gradle'))) {
+                context.projectType = 'java';
+                context.packageManager = 'gradle';
+            }
+            // Git information
+            const gitPath = path_1.default.join(workspacePath, '.git');
+            if (await fs_extra_1.default.pathExists(gitPath)) {
+                context.gitRepository = await this.getGitInfo(workspacePath);
+            }
+            return context;
+        }
+        catch (error) {
+            logger_1.logger.debug('Failed to detect project context:', error);
+            return undefined;
+        }
+    }
+    async getGitInfo(workspacePath) {
+        // Simplified git info extraction
+        return {
+            remote: 'origin',
+            branch: 'main',
+            status: 'clean',
+            hasUncommittedChanges: false,
+        };
+    }
+    getDefaultPreferences() {
+        return {
+            defaultModel: 'claude-3-5-sonnet-20241022',
+            preferredOutputFormat: 'table',
+            confirmDestructiveCommands: true,
+            enableStreamingResponses: true,
+            maxHistoryLength: 100,
+            autoSave: true,
+            theme: 'auto',
+            verbosity: 'normal',
+            aliases: {},
+            favorites: [],
+            workspacePreferences: {},
+        };
+    }
+    async loadUserPreferences(userId) {
+        const prefsPath = path_1.default.join(this.config.persistencePath, 'users', `${userId}.json`);
+        if (await fs_extra_1.default.pathExists(prefsPath)) {
+            try {
+                const saved = await fs_extra_1.default.readJson(prefsPath);
+                return { ...this.getDefaultPreferences(), ...saved };
+            }
+            catch (error) {
+                logger_1.logger.warn(`Failed to load preferences for ${userId}:`, error);
+            }
+        }
+        return this.getDefaultPreferences();
+    }
+    async saveUserPreferences(userId, preferences) {
+        const prefsPath = path_1.default.join(this.config.persistencePath, 'users', `${userId}.json`);
+        await fs_extra_1.default.ensureDir(path_1.default.dirname(prefsPath));
+        await fs_extra_1.default.writeJson(prefsPath, preferences, { spaces: 2 });
+    }
+    async persistSession(session) {
+        const sessionPath = path_1.default.join(this.config.persistencePath, `${session.id}.json`);
+        const serialized = this.serializeSession(session);
+        await fs_extra_1.default.writeJson(sessionPath, serialized, { spaces: 2 });
+    }
+    async loadSession(sessionId) {
+        const sessionPath = path_1.default.join(this.config.persistencePath, `${sessionId}.json`);
+        if (await fs_extra_1.default.pathExists(sessionPath)) {
+            try {
+                const data = await fs_extra_1.default.readJson(sessionPath);
+                return this.deserializeSession(data);
+            }
+            catch (error) {
+                logger_1.logger.warn(`Failed to load session ${sessionId}:`, error);
+            }
+        }
+        return null;
+    }
+    serializeSession(session) {
+        return {
+            ...session,
+            created: session.created.toISOString(),
+            lastAccessed: session.lastAccessed.toISOString(),
+            recentCommands: session.recentCommands.map(cmd => ({
+                ...cmd,
+                timestamp: cmd.timestamp.toISOString(),
+            })),
+            contextStack: session.contextStack.map(ctx => ({
+                ...ctx,
+                timestamp: ctx.timestamp.toISOString(),
+            })),
+            projectContext: session.projectContext
+                ? {
+                    ...session.projectContext,
+                    lastAnalysis: session.projectContext.lastAnalysis
+                        ? {
+                            ...session.projectContext.lastAnalysis,
+                            timestamp: session.projectContext.lastAnalysis.timestamp.toISOString(),
+                        }
+                        : undefined,
+                }
+                : undefined,
+        };
+    }
+    deserializeSession(data) {
+        return {
+            ...data,
+            created: new Date(data.created),
+            lastAccessed: new Date(data.lastAccessed),
+            recentCommands: data.recentCommands.map((cmd) => ({
+                ...cmd,
+                timestamp: new Date(cmd.timestamp),
+            })),
+            contextStack: data.contextStack.map((ctx) => ({
+                ...ctx,
+                timestamp: new Date(ctx.timestamp),
+            })),
+            projectContext: data.projectContext
+                ? {
+                    ...data.projectContext,
+                    lastAnalysis: data.projectContext.lastAnalysis
+                        ? {
+                            ...data.projectContext.lastAnalysis,
+                            timestamp: new Date(data.projectContext.lastAnalysis.timestamp),
+                        }
+                        : undefined,
+                }
+                : undefined,
+        };
+    }
+    async loadWorkspace(workspacePath) {
+        const workspacesDir = path_1.default.join(this.config.persistencePath, 'workspaces');
+        const workspaceFile = path_1.default.join(workspacesDir, `${Buffer.from(workspacePath).toString('base64')}.json`);
+        if (await fs_extra_1.default.pathExists(workspaceFile)) {
+            try {
+                const data = await fs_extra_1.default.readJson(workspaceFile);
+                data.lastAccessed = new Date(data.lastAccessed);
+                return data;
+            }
+            catch (error) {
+                logger_1.logger.warn(`Failed to load workspace ${workspacePath}:`, error);
+            }
+        }
+        return null;
+    }
+    async saveWorkspace(workspace) {
+        const workspacesDir = path_1.default.join(this.config.persistencePath, 'workspaces');
+        const workspaceFile = path_1.default.join(workspacesDir, `${Buffer.from(workspace.path).toString('base64')}.json`);
+        await fs_extra_1.default.ensureDir(workspacesDir);
+        await fs_extra_1.default.writeJson(workspaceFile, {
+            ...workspace,
+            lastAccessed: workspace.lastAccessed.toISOString(),
+        }, { spaces: 2 });
+    }
+    async loadAllWorkspaces() {
+        const workspacesDir = path_1.default.join(this.config.persistencePath, 'workspaces');
+        if (await fs_extra_1.default.pathExists(workspacesDir)) {
+            const files = await fs_extra_1.default.readdir(workspacesDir);
+            for (const file of files) {
+                if (file.endsWith('.json')) {
+                    try {
+                        const data = await fs_extra_1.default.readJson(path_1.default.join(workspacesDir, file));
+                        data.lastAccessed = new Date(data.lastAccessed);
+                        this.workspaces.set(data.path, data);
+                    }
+                    catch (error) {
+                        logger_1.logger.debug(`Failed to load workspace file ${file}:`, error);
+                    }
+                }
+            }
+        }
+    }
+    async backupActiveSessions() {
+        for (const session of this.activeSessions.values()) {
+            await this.persistSession(session);
+        }
+        logger_1.logger.debug(`Backed up ${this.activeSessions.size} active sessions`);
+    }
+    async analyzeCommandPatterns(session) {
+        // Simple pattern analysis for learning user behavior
+        const recentCommands = session.recentCommands.slice(-10);
+        if (recentCommands.length >= 3) {
+            // Look for command sequences
+            const sequences = [];
+            for (let i = 0; i < recentCommands.length - 1; i++) {
+                const current = recentCommands[i];
+                const next = recentCommands[i + 1];
+                if (current?.command && next?.command) {
+                    sequences.push(`${current.command} -> ${next.command}`);
+                }
+            }
+            // Store patterns in temporary data for future suggestions
+            if (!session.temporaryData['commandPatterns']) {
+                session.temporaryData['commandPatterns'] = [];
+            }
+            session.temporaryData['commandPatterns'].push(...sequences);
+            // Keep only recent patterns
+            session.temporaryData['commandPatterns'] =
+                session.temporaryData['commandPatterns'].slice(-20);
+        }
+    }
+    sessionToCsv(session) {
+        const headers = ['Timestamp', 'Command', 'Success', 'Duration'];
+        const rows = [headers];
+        session.recentCommands.forEach(cmd => {
+            rows.push([
+                cmd.timestamp.toISOString(),
+                `"${cmd.command.replace(/"/g, '""')}"`,
+                cmd.success.toString(),
+                cmd.duration.toString(),
+            ]);
+        });
+        return rows.map(row => row.join(',')).join('\n');
+    }
+    /**
+     * Cleanup resources
+     */
+    destroy() {
+        if (this.backupTimer) {
+            clearInterval(this.backupTimer);
+        }
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+        }
+        this.activeSessions.clear();
+        this.workspaces.clear();
+        this.removeAllListeners();
+    }
+}
+exports.SessionManager = SessionManager;
+exports.default = SessionManager;
+//# sourceMappingURL=session-manager.js.map