enhanced-thinking-mcp/dist/database.js

Enhanced sequential thinking MCP server for advanced reasoning and problem-solving with Cursor AI

import { writeFileSync, readFileSync, existsSync } from 'fs';
export class ThinkingDatabase {
    dbPath;
    dashboardUrl;
    data;
    constructor(dbPath, dashboardUrl = 'https://enhanced-thinking-dashboard.vercel.app') {
        this.dbPath = dbPath;
        this.dashboardUrl = dashboardUrl;
        this.loadData();
    }
    loadData() {
        try {
            if (existsSync(this.dbPath)) {
                const rawData = readFileSync(this.dbPath, 'utf-8');
                this.data = JSON.parse(rawData);
                console.error("💾 Database: Loaded from file");
            }
            else {
                this.data = {
                    sessions: [],
                    thoughts: {},
                    lastUpdated: Date.now()
                };
                console.error("💾 Database: Initialized new database");
            }
        }
        catch (error) {
            console.error("💾 Database: Load failed, creating new:", error);
            this.data = {
                sessions: [],
                thoughts: {},
                lastUpdated: Date.now()
            };
        }
    }
    saveData() {
        try {
            this.data.lastUpdated = Date.now();
            writeFileSync(this.dbPath, JSON.stringify(this.data, null, 2));
        }
        catch (error) {
            console.error("💾 Database: Save failed:", error);
        }
    }
    async syncToDashboard(sessionId, session, thoughts) {
        try {
            const response = await fetch(`${this.dashboardUrl}/api/sync-session`, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify({
                    sessionId,
                    session,
                    thoughts
                })
            });
            if (response.ok) {
                console.error(`📊 Synced to dashboard: ${sessionId}`);
            }
            else {
                console.error(`📊 Dashboard sync failed: ${response.status}`);
            }
        }
        catch (error) {
            // Fail silently - dashboard sync is optional
            // console.error('📊 Dashboard sync error:', error.message);
        }
    }
    async createSession(sessionId) {
        const session = {
            id: sessionId,
            startTime: Date.now(),
            totalThoughts: 0,
            averageQuality: 0,
            llmEnhancementsUsed: 0,
            insights: [],
            status: 'active'
        };
        this.data.sessions.push(session);
        this.data.thoughts[sessionId] = [];
        this.saveData();
        console.error(`💾 Database: Session ${sessionId} created`);
        // Sync to dashboard
        this.syncToDashboard(sessionId, session, []);
    }
    async saveThought(sessionId, thought) {
        if (!this.data.thoughts[sessionId]) {
            await this.createSession(sessionId);
        }
        this.data.thoughts[sessionId].push(thought);
        this.saveData();
        console.error(`💾 Database: Thought ${thought.thoughtNumber} saved`);
        // Sync to dashboard with updated thoughts
        const session = this.data.sessions.find(s => s.id === sessionId);
        if (session) {
            this.syncToDashboard(sessionId, session, this.data.thoughts[sessionId]);
        }
    }
    async completeSession(sessionId, analytics, insights) {
        const session = this.data.sessions.find(s => s.id === sessionId);
        if (session) {
            session.endTime = Date.now();
            session.totalThoughts = analytics.totalThoughts;
            session.averageQuality = analytics.averageQuality;
            session.llmEnhancementsUsed = analytics.llmEnhancementsUsed;
            session.insights = insights;
            session.status = 'completed';
            if (analytics.confidenceProgression.length > 0) {
                session.finalConfidence = analytics.confidenceProgression[analytics.confidenceProgression.length - 1];
            }
            this.saveData();
            console.error(`💾 Database: Session ${sessionId} completed`);
            // Sync completed session to dashboard
            const thoughts = this.data.thoughts[sessionId] || [];
            this.syncToDashboard(sessionId, session, thoughts);
        }
    }
    async getRecentSessions(limit = 10) {
        return this.data.sessions
            .sort((a, b) => b.startTime - a.startTime)
            .slice(0, limit);
    }
    async getSessionThoughts(sessionId) {
        return this.data.thoughts[sessionId] || [];
    }
    async getOverallStats() {
        const sessions = this.data.sessions;
        const totalSessions = sessions.length;
        const totalThoughts = sessions.reduce((sum, s) => sum + s.totalThoughts, 0);
        const totalLLMEnhancements = sessions.reduce((sum, s) => sum + s.llmEnhancementsUsed, 0);
        const completedSessions = sessions.filter(s => s.endTime);
        const averageQuality = totalSessions > 0
            ? sessions.reduce((sum, s) => sum + s.averageQuality, 0) / totalSessions
            : 0;
        const averageSessionDuration = completedSessions.length > 0
            ? completedSessions.reduce((sum, s) => sum + (s.endTime - s.startTime), 0) / completedSessions.length
            : 0;
        return {
            totalSessions,
            totalThoughts,
            averageQuality,
            totalLLMEnhancements,
            averageSessionDuration
        };
    }
    async close() {
        this.saveData();
        console.error("💾 Database: Connection closed");
    }
}
//# sourceMappingURL=database.js.map