@wundr.io/cli 1.0.10 → 1.0.12

package/dist/context/session-manager.js

@@ -1,686 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SessionManager = void 0;
-const tslib_1 = require("tslib");
-const events_1 = require("events");
-const path_1 = tslib_1.__importDefault(require("path"));
-const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
-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