vibe-coder-mcp
Version:
Production-ready MCP server with complete agent integration, multi-transport support, and comprehensive development automation tools for AI-assisted workflows.
241 lines (240 loc) • 11.5 kB
JavaScript
import logger from '../../../logger.js';
export class ResponseGenerator {
static instance;
config;
constructor() {
this.config = {
includeSuggestions: true,
maxSuggestions: 3,
enablePersonalization: true,
tone: 'casual',
includeEmojis: true
};
}
static getInstance() {
if (!ResponseGenerator.instance) {
ResponseGenerator.instance = new ResponseGenerator();
}
return ResponseGenerator.instance;
}
generateResponse(executionResult, recognizedIntent, context) {
try {
logger.debug({
intent: recognizedIntent.intent,
success: executionResult.success,
sessionId: context.sessionId
}, 'Generating natural language response');
if (executionResult.success) {
return this.generateSuccessResponse(executionResult, recognizedIntent, context);
}
else {
return this.generateErrorResponse(executionResult, recognizedIntent, context);
}
}
catch (error) {
logger.error({ err: error, sessionId: context.sessionId }, 'Response generation failed');
return {
text: 'I encountered an error while processing your request. Please try again.',
type: 'error',
requiresConfirmation: false,
suggestions: ['Try rephrasing your request', 'Check the command syntax'],
metadata: {
generatedAt: new Date(),
method: 'template',
confidence: 0
}
};
}
}
generateSuccessResponse(executionResult, recognizedIntent, context) {
const baseText = this.extractTextFromResult(executionResult.result);
const personalizedText = this.personalizeResponse(baseText, recognizedIntent, context);
const suggestions = this.generateSuggestions(executionResult, recognizedIntent, context);
return {
text: personalizedText,
type: 'success',
data: {
intent: recognizedIntent.intent,
confidence: recognizedIntent.confidence,
updatedContext: executionResult.updatedContext
},
suggestions,
requiresConfirmation: false,
metadata: {
generatedAt: new Date(),
method: 'template',
confidence: recognizedIntent.confidence
}
};
}
generateErrorResponse(executionResult, recognizedIntent, context) {
const baseText = this.extractTextFromResult(executionResult.result);
const helpfulText = this.makeErrorHelpful(baseText, recognizedIntent, context);
const suggestions = this.generateErrorSuggestions(executionResult, recognizedIntent, context);
return {
text: helpfulText,
type: 'error',
data: {
intent: recognizedIntent.intent,
confidence: recognizedIntent.confidence
},
suggestions,
requiresConfirmation: false,
metadata: {
generatedAt: new Date(),
method: 'template',
confidence: recognizedIntent.confidence
}
};
}
extractTextFromResult(result) {
if (result.content && result.content.length > 0) {
const textContent = result.content.find(c => c.type === 'text');
return textContent ? textContent.text : 'Command completed successfully.';
}
return 'Command completed successfully.';
}
personalizeResponse(text, recognizedIntent, context) {
if (!this.config.enablePersonalization) {
return text;
}
let personalizedText = text;
if (context.conversationHistory.length === 0) {
const greeting = this.getContextualGreeting(recognizedIntent.intent);
if (greeting) {
personalizedText = `${greeting}\n\n${personalizedText}`;
}
}
if (context.currentProject && !text.includes(context.currentProject)) {
const projectContext = this.getProjectContext(recognizedIntent.intent, context.currentProject);
if (projectContext) {
personalizedText += `\n\n${projectContext}`;
}
}
personalizedText = this.adjustTone(personalizedText, this.config.tone);
return personalizedText;
}
getContextualGreeting(intent) {
const greetings = {
'create_project': '🚀 Great! Let\'s get your new project started.',
'create_task': '📝 Perfect! I\'ll help you create that task.',
'list_projects': '📋 Here\'s an overview of your projects.',
'list_tasks': '📝 Let me show you your tasks.',
'run_task': '⚡ Time to get some work done!',
'check_status': '📊 Let me check on that for you.',
'decompose_task': '🔍 I\'ll break that down into manageable pieces.',
'decompose_epic': '📋 I\'ll decompose that epic into actionable tasks.',
'refine_task': '✨ Let\'s refine that task to make it clearer.',
'assign_task': '👥 I\'ll help you assign that task.',
'get_help': '💡 I\'m here to help!',
'open_project': '📂 Opening that project for you.'
};
return greetings[intent] || null;
}
getProjectContext(intent, currentProject) {
const contextMessages = {
'create_task': `This task will be added to your current project: ${currentProject}.`,
'list_tasks': `Showing tasks for your current project: ${currentProject}.`,
'check_status': `Current project context: ${currentProject}.`,
'run_task': `Executing within project: ${currentProject}.`
};
return contextMessages[intent] || null;
}
adjustTone(text, tone) {
switch (tone) {
case 'formal':
return text
.replace(/Great!/g, 'Excellent.')
.replace(/Perfect!/g, 'Very good.')
.replace(/Let's/g, 'We shall')
.replace(/I'll/g, 'I will');
case 'technical':
return text
.replace(/Great!/g, 'Operation successful.')
.replace(/Perfect!/g, 'Command executed.')
.replace(/Let me/g, 'Processing');
case 'casual':
default:
return text;
}
}
generateSuggestions(executionResult, recognizedIntent, context) {
const suggestions = [];
if (executionResult.followUpSuggestions) {
suggestions.push(...executionResult.followUpSuggestions.slice(0, this.config.maxSuggestions));
}
if (suggestions.length < this.config.maxSuggestions) {
const intentSuggestions = this.getIntentSpecificSuggestions(recognizedIntent.intent, context);
const remainingSlots = this.config.maxSuggestions - suggestions.length;
suggestions.push(...intentSuggestions.slice(0, remainingSlots));
}
return suggestions;
}
generateErrorSuggestions(executionResult, recognizedIntent, _context) {
const suggestions = [
'Try rephrasing your request',
'Check the command syntax',
'Ask for help with available commands'
];
const intentSuggestions = this.getErrorSuggestionsForIntent(recognizedIntent.intent);
suggestions.push(...intentSuggestions);
return suggestions.slice(0, this.config.maxSuggestions);
}
getIntentSpecificSuggestions(intent, _context) {
const suggestions = {
'create_project': ['Add tasks to your project', 'Set project priorities', 'Invite team members'],
'update_project': ['Modify project settings', 'Change project configuration', 'Update project details'],
'create_task': ['Run the task', 'Set task dependencies', 'Assign the task'],
'list_projects': ['Create a new project', 'Check project status', 'Archive old projects'],
'list_tasks': ['Create a new task', 'Run a task', 'Update task status'],
'run_task': ['Check task progress', 'View execution logs', 'Stop task execution'],
'check_status': ['Update project status', 'View detailed reports', 'Set status alerts'],
'decompose_task': ['Review subtasks', 'Assign subtasks', 'Set task priorities'],
'decompose_epic': ['Review epic tasks', 'Set task priorities', 'Assign tasks to developers'],
'decompose_project': ['Review project breakdown', 'Create epics', 'Set project priorities'],
'search_files': ['Search for content', 'List all files', 'Open a file'],
'search_content': ['Search for files', 'Show file details', 'Edit a file'],
'refine_task': ['Update task description', 'Set acceptance criteria', 'Add task notes'],
'assign_task': ['Set task deadlines', 'Add task comments', 'Track assignment'],
'get_help': ['View command examples', 'Check documentation', 'Contact support'],
'open_project': ['View project details', 'Edit project settings', 'Add project members'],
'parse_prd': ['Generate epics from PRD', 'Create tasks from features', 'Review PRD content'],
'parse_tasks': ['Execute task list', 'Review task dependencies', 'Assign tasks to agents'],
'import_artifact': ['Parse specific artifact type', 'Review imported content', 'Create project from artifact'],
'unrecognized_intent': ['Try being more specific', 'Ask for help', 'View available commands'],
'clarification_needed': ['Provide more details', 'Be more specific', 'Try a different approach'],
'unknown': ['Try a different command', 'Ask for help', 'View available commands']
};
return suggestions[intent] || [];
}
getErrorSuggestionsForIntent(intent) {
const errorSuggestions = {
'create_project': ['Provide a project name', 'Check project name format'],
'create_task': ['Specify task details', 'Set a project context'],
'run_task': ['Provide a valid task ID', 'Check task status'],
'check_status': ['Specify what to check', 'Provide project or task name']
};
return errorSuggestions[intent] || [];
}
makeErrorHelpful(errorText, recognizedIntent, _context) {
let helpfulText = errorText;
if (recognizedIntent.confidence < 0.5) {
helpfulText += '\n\nI wasn\'t very confident about understanding your request. ';
helpfulText += 'Could you try rephrasing it more specifically?';
}
if (errorText.includes('required')) {
helpfulText += '\n\nFor example, try: "Create a project called MyApp" or "Run task 123"';
}
return helpfulText;
}
updateConfig(newConfig) {
this.config = { ...this.config, ...newConfig };
logger.info({ config: this.config }, 'Response Generator configuration updated');
}
getConfig() {
return { ...this.config };
}
}
export function getResponseGenerator() {
return ResponseGenerator.getInstance();
}