ableton-mcp-server-rag/dist/main.js

Ableton Live MCP depend on Ableton JS

// src/main.ts
import { createLogger } from './utils/logger.js';
import path from 'path';
import { initAbleton } from './ableton.js';
import { initializeDataSource } from './db.js';
import os from 'os';
import PerformanceMonitor from './utils/performance-monitor.js';
import fs from 'fs';
// NEW: Import dotenv
import dotenv from 'dotenv';
// NEW: Load environment variables from .env file
dotenv.config();
// Import tool classes
import BrowserTools from './tools/browser-tools.js';
import ClipTools from './tools/clip-tools.js';
import DeviceTools from './tools/device-tools.js';
import HistoryTools from './tools/history-tools.js';
import SongTools from './tools/song-tools.js';
import TrackTools from './tools/track-tools.js';
import ExtraTools from './tools/extra-tools.js';
import ApplicationTools from './tools/application-tools.js';
// NEW: Create instances of all tool classes
const browserToolsInstance = new BrowserTools();
const clipToolsInstance = new ClipTools();
const deviceToolsInstance = new DeviceTools();
const historyToolsInstance = new HistoryTools();
const songToolsInstance = new SongTools();
const trackToolsInstance = new TrackTools();
const extraToolsInstance = new ExtraTools();
const applicationToolsInstance = new ApplicationTools();
let ragToolsInstance = null; // Will be instantiated later if RAG is successful
// Set environment variables
process.env.NODE_OPTIONS = process.env.NODE_OPTIONS || '--max-old-space-size=4096';
// Configure base path
const basePath = process.env.BASE_PATH || path.join(os.homedir(), '.ableton-copilot-mcp');
const logFile = path.join(basePath, 'logs', 'ableton.log');
const dbFile = path.join(basePath, 'data.db');
export const logger = createLogger(logFile);
const logsDir = path.join(basePath, 'logs');
if (!fs.existsSync(logsDir)) {
    fs.mkdirSync(logsDir, { recursive: true });
}
async function startApplication() {
    try {
        // Initialize database
        await initializeDataSource(dbFile);
        // Dynamically import and initialize RAG components to avoid circular dependencies
        const ragModule = await import('./mcp/rag.js');
        const toolVectorModule = await import('./mcp/tool-vector.js');
        const coreModule = await import('./mcp/core.js');
        const { initRag } = ragModule;
        const { initToolVectorStore } = toolVectorModule;
        const { startServer: startMcp } = coreModule;
        // Initialize RAG FIRST (before loading tools that depend on it)
        try {
            await initRag();
            logger.info('RAG initialized successfully');
        }
        catch (err) {
            logger.error('Failed to initialize RAG:', err);
            // Non-fatal: continue booting MCP without RAG
        }
        // Initialize RAG tools AFTER RAG is ready
        let RagTools = null;
        try {
            const RagToolsModule = await import('./mcp/rag-tools.js');
            RagTools = RagToolsModule.default;
            // NEW: Assign to the instance declared above
            ragToolsInstance = new RagTools();
            logger.info('✅ RAG tools loaded and instantiated successfully');
        }
        catch (error) {
            logger.error('❌ Failed to load RAG tools:', error);
        }
        // Start MCP server with ALL tool INSTANCES
        // NEW: Pass instances instead of classes
        const allToolInstances = [
            browserToolsInstance,
            clipToolsInstance,
            deviceToolsInstance,
            historyToolsInstance,
            songToolsInstance,
            trackToolsInstance,
            extraToolsInstance,
            applicationToolsInstance
        ];
        // Only add ragToolsInstance if it was successfully created
        if (ragToolsInstance) {
            allToolInstances.push(ragToolsInstance);
        }
        await startMcp(); // tools parameter removed
        // Initialize tool vector store after MCP server and tools are registered
        try {
            await initToolVectorStore();
            logger.info('Tool vector store initialized successfully');
        }
        catch (err) {
            logger.error('Failed to initialize tool vector store:', err);
            // Non-fatal: continue without tool recommendations
        }
        // Initialize Ableton connection
        await initAbleton(logger);
        logger.info('🎉 Ableton Copilot MCP initialized successfully with all tools');
    }
    catch (error) {
        logger.error('Error initializing Ableton Copilot MCP:', error);
        throw error;
    }
}
// Start the application
startApplication().catch(error => {
    console.error('💥 Fatal error starting application:', error);
    process.exit(1);
});
// Set up performance monitoring timer (after application starts)
setTimeout(() => {
    setInterval(() => {
        PerformanceMonitor.instance.logMetrics();
        // Reset metrics every hour
        if (new Date().getHours() % 1 === 0 && new Date().getMinutes() === 0) {
            logger.info('Resetting performance metrics');
            PerformanceMonitor.instance.resetMetrics();
        }
    }, 60 * 60 * 1000); // Log every hour
}, 5000); // Start monitoring after 5 seconds
//# sourceMappingURL=main.js.map