index.js•10.3 kB
"use strict";
/**
* MCP Prompt Enhancer Server
*
* Main entry point for the Model Context Protocol server that provides
* intelligent prompt preprocessing with adaptive context management.
*/
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.startServer = startServer;
const path_1 = __importDefault(require("path"));
const fs_extra_1 = __importDefault(require("fs-extra"));
// Use STDIO for communication instead of remote MCP
// This simplifies the implementation and eliminates network dependencies
const readline_1 = __importDefault(require("readline"));
const ProjectContextManager_1 = __importDefault(require("./context/ProjectContextManager"));
const TaskTracker_1 = __importDefault(require("./tracker/TaskTracker"));
const PromptEnhancer_1 = __importDefault(require("./enhancer/PromptEnhancer"));
const Logger_1 = __importStar(require("./utils/Logger"));
// Default configuration
const DEFAULT_CONFIG = {
port: 3000,
contextCacheTTL: 900, // 15 minutes in seconds
maxContextSize: 10000,
logLevel: 'info',
ignorePatterns: ['node_modules', 'dist', '.git', 'build', 'coverage', '*.log'],
};
// Main logger instance
const log = Logger_1.default.createChildLogger('Server');
/**
* Load configuration from file or environment
*/
function loadConfig() {
const configPath = path_1.default.join(process.cwd(), 'mcp-prompt-enhancer.config.js');
let config = { ...DEFAULT_CONFIG };
try {
// Try to load config file if it exists
if (fs_extra_1.default.existsSync(configPath)) {
try {
const userConfig = require(configPath);
config = { ...config, ...userConfig };
log.info('Loaded configuration from mcp-prompt-enhancer.config.js');
}
catch (error) {
log.error('Error loading configuration file', error);
}
}
else {
log.info('No configuration file found, using defaults');
}
// Override with environment variables if present
if (process.env.MCP_PORT) {
config.port = parseInt(process.env.MCP_PORT, 10);
}
if (process.env.MCP_LOG_LEVEL) {
config.logLevel = process.env.MCP_LOG_LEVEL;
}
// Set logger level
const logLevelMap = {
'debug': Logger_1.LogLevel.DEBUG,
'info': Logger_1.LogLevel.INFO,
'warn': Logger_1.LogLevel.WARN,
'error': Logger_1.LogLevel.ERROR,
};
Logger_1.default.configure({
level: logLevelMap[config.logLevel.toLowerCase()] ?? Logger_1.LogLevel.INFO,
isDevelopment: process.env.NODE_ENV !== 'production',
});
return config;
}
catch (error) {
log.error('Error in configuration setup', error);
return config;
}
}
/**
* Initialize core components
*/
function initializeComponents(config) {
// Create project context manager
const projectContextManager = new ProjectContextManager_1.default({
projectPath: process.cwd(),
ignorePatterns: config.ignorePatterns,
cacheTTL: config.contextCacheTTL,
maxContextSize: config.maxContextSize,
});
// Create task tracker
const taskTracker = new TaskTracker_1.default();
// Create prompt enhancer
const promptEnhancer = new PromptEnhancer_1.default(projectContextManager, taskTracker, {
maxContextSize: config.maxContextSize,
contextFormat: 'markdown',
});
return {
projectContextManager,
taskTracker,
promptEnhancer,
};
}
/**
* Start the STDIO-based MCP server
*/
async function startServer() {
try {
// Load configuration
const config = loadConfig();
log.info('Starting MCP Prompt Enhancer STDIO Server');
// Initialize components
const { projectContextManager, taskTracker, promptEnhancer } = initializeComponents(config);
// Create readline interface for STDIO communication
const rl = readline_1.default.createInterface({
input: process.stdin,
output: process.stdout,
terminal: false
});
log.info('STDIO server ready. Waiting for input...');
// Process incoming messages
rl.on('line', async (line) => {
try {
const request = JSON.parse(line);
const { action, params } = request;
let response;
switch (action) {
case 'enhance_prompt':
try {
const { prompt, taskType, focusFiles, includeFullContext } = params;
log.info(`Enhancing prompt: "${prompt.substring(0, 50)}${prompt.length > 50 ? '...' : ''}"`);
const result = await promptEnhancer.enhancePrompt({
prompt,
taskType: taskType,
focusFiles: focusFiles,
includeFullContext: !!includeFullContext,
});
log.info(`Enhanced prompt with ${result.contextSize} tokens of context for ${result.taskType} task`);
response = {
status: 'success',
data: {
enhancedPrompt: result.enhancedPrompt,
taskType: result.taskType,
focusArea: result.focusArea,
contextAdded: result.contextAdded,
contextSize: result.contextSize,
}
};
}
catch (error) {
log.error('Error enhancing prompt', error);
response = {
status: 'error',
error: error.message
};
}
break;
case 'set_project_context':
try {
const { projectPath, forceRefresh } = params;
if (projectPath) {
log.info(`Project path specified: ${projectPath}, but changing project path is not supported yet`);
}
log.info(`Refreshing project context${forceRefresh ? ' (forced)' : ''}`);
const context = await projectContextManager.getContext(!!forceRefresh);
response = {
status: 'success',
data: {
message: `Project context updated for ${context.projectName}`,
projectName: context.projectName,
frameworks: context.frameworks,
timestamp: new Date(context.timestamp).toISOString(),
}
};
}
catch (error) {
log.error('Error setting project context', error);
response = {
status: 'error',
error: error.message
};
}
break;
default:
response = {
status: 'error',
error: `Unknown action: ${action}`
};
}
// Send response
process.stdout.write(JSON.stringify(response) + '\n');
}
catch (error) {
log.error('Error processing request', error);
process.stdout.write(JSON.stringify({
status: 'error',
error: 'Invalid JSON input'
}) + '\n');
}
});
// Handle shutdown
const shutdown = () => {
log.info('Shutting down server...');
rl.close();
projectContextManager.dispose();
process.exit(0);
};
process.on('SIGINT', shutdown);
process.on('SIGTERM', shutdown);
}
catch (error) {
log.error('Failed to start server', error);
process.exit(1);
}
}
// Auto-start when executed directly
if (require.main === module) {
startServer();
}
//# sourceMappingURL=index.js.map