bc-code-intelligence-mcp 1.1.1 → 1.2.0

package/dist/services/roleplay-engine.js

@@ -0,0 +1,672 @@
+/**
+ * BC Specialist Roleplay Engine
+ *
+ * Brings specialist personas to life through personality-driven responses,
+ * consistent character adoption, and context-aware knowledge integration.
+ */
+export class BCSpecialistRoleplayEngine {
+    layerService;
+    knowledgeService;
+    config;
+    responseTemplates = new Map();
+    knowledgeRetriever;
+    constructor(layerService, knowledgeService, config) {
+        this.layerService = layerService;
+        this.knowledgeService = knowledgeService;
+        this.config = {
+            personality_strength: 'moderate',
+            response_length: 'adaptive',
+            knowledge_integration: 'balanced',
+            suggest_handoffs: true,
+            suggest_collaborations: true,
+            learn_user_preferences: true,
+            adapt_communication_style: true,
+            ...config
+        };
+        this.knowledgeRetriever = new BCKnowledgeRetriever(layerService, knowledgeService);
+        this.initializeResponseTemplates();
+    }
+    /**
+     * Generate a personality-driven response from a specialist
+     */
+    async generateResponse(context) {
+        const { specialist, userMessage, session } = context;
+        // Analyze the specialist's personality
+        const personality = this.analyzePersonality(specialist);
+        // Find relevant knowledge
+        const relevantTopics = await this.knowledgeRetriever.findRelevantTopics(userMessage, specialist.expertise.primary.concat(specialist.expertise.secondary), 5);
+        // Generate personality-driven response
+        const response = await this.buildPersonalityResponse(specialist, personality, context, relevantTopics);
+        // Apply session context updates
+        const contextUpdates = this.generateContextUpdates(context, relevantTopics);
+        // Check for collaboration opportunities
+        const suggestedHandoffs = await this.suggestCollaborations(context, relevantTopics);
+        return {
+            content: response.content,
+            specialist_id: specialist.specialist_id,
+            personality_elements: response.personality_elements,
+            topics_referenced: relevantTopics.map(t => t.id),
+            knowledge_applied: relevantTopics.map(topic => ({
+                topic_id: topic.id,
+                application_context: this.getApplicationContext(topic, userMessage)
+            })),
+            suggested_handoffs: suggestedHandoffs,
+            context_updates: contextUpdates,
+            recommendations_added: response.recommendations,
+            response_type: response.response_type,
+            confidence_level: response.confidence_level
+        };
+    }
+    /**
+     * Analyze user message to suggest appropriate specialist
+     */
+    async suggestSpecialist(userMessage, currentContext) {
+        const specialists = await this.layerService.getAllSpecialists();
+        const suggestions = [];
+        for (const specialist of specialists) {
+            const confidence = await this.calculateSpecialistConfidence(userMessage, specialist, currentContext);
+            if (confidence > 0.3) { // Threshold for relevant suggestions
+                suggestions.push({
+                    specialist_id: specialist.specialist_id,
+                    confidence,
+                    reasoning: this.generateSuggestionReasoning(userMessage, specialist, confidence)
+                });
+            }
+        }
+        return suggestions.sort((a, b) => b.confidence - a.confidence).slice(0, 3);
+    }
+    /**
+     * Generate a specialist greeting for session start
+     */
+    async generateGreeting(specialist, context) {
+        const personality = this.analyzePersonality(specialist);
+        const greeting = this.buildGreeting(specialist, personality, context);
+        return {
+            content: greeting,
+            specialist_id: specialist.specialist_id,
+            personality_elements: {
+                greeting_used: true,
+                characteristic_phrases: [specialist.persona.greeting],
+                expertise_demonstrated: specialist.expertise.primary.slice(0, 2),
+                communication_style_applied: specialist.persona.communication_style
+            },
+            topics_referenced: [],
+            knowledge_applied: [],
+            response_type: 'greeting',
+            confidence_level: 'high'
+        };
+    }
+    /**
+     * Generate handoff message when transferring between specialists
+     */
+    async generateHandoff(fromSpecialist, toSpecialist, context) {
+        const fromPersonality = this.analyzePersonality(fromSpecialist);
+        const toPersonality = this.analyzePersonality(toSpecialist);
+        const farewell = this.buildHandoffFarewell(fromSpecialist, toSpecialist, context);
+        const introduction = this.buildHandoffIntroduction(toSpecialist, fromSpecialist, context);
+        return {
+            farewell: {
+                content: farewell,
+                specialist_id: fromSpecialist.specialist_id,
+                personality_elements: {
+                    greeting_used: false,
+                    characteristic_phrases: [],
+                    expertise_demonstrated: [],
+                    communication_style_applied: fromSpecialist.persona.communication_style
+                },
+                topics_referenced: [],
+                knowledge_applied: [],
+                response_type: 'handoff',
+                confidence_level: 'high'
+            },
+            introduction: {
+                content: introduction,
+                specialist_id: toSpecialist.specialist_id,
+                personality_elements: {
+                    greeting_used: true,
+                    characteristic_phrases: [toSpecialist.persona.greeting],
+                    expertise_demonstrated: toSpecialist.expertise.primary.slice(0, 2),
+                    communication_style_applied: toSpecialist.persona.communication_style
+                },
+                topics_referenced: [],
+                knowledge_applied: [],
+                response_type: 'handoff',
+                confidence_level: 'high'
+            }
+        };
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+    /**
+     * Get personality analysis for a specialist
+     */
+    analyzePersonality(specialist) {
+        return {
+            communication_style: specialist.persona.communication_style,
+            expertise_focus: specialist.expertise.primary,
+            problem_approach: this.extractProblemApproach(specialist),
+            collaboration_style: this.extractCollaborationStyle(specialist),
+            characteristic_phrases: [
+                specialist.persona.greeting,
+                ...this.extractCharacteristicPhrases(specialist)
+            ]
+        };
+    }
+    /**
+     * Build personality-driven response
+     */
+    async buildPersonalityResponse(specialist, personality, context, relevantTopics) {
+        const { userMessage, session } = context;
+        // Start with specialist greeting if it's a new conversation
+        let response = session.messageCount <= 1 ? `${specialist.persona.greeting} ` : '';
+        // Apply personality-driven response patterns
+        response += await this.generatePersonalityContent(specialist, personality, userMessage, relevantTopics, context);
+        // Add recommendations based on knowledge
+        const recommendations = this.generateRecommendations(relevantTopics, userMessage);
+        // Determine response type and confidence
+        const responseType = this.determineResponseType(userMessage, relevantTopics);
+        const confidenceLevel = this.calculateConfidenceLevel(specialist, userMessage, relevantTopics);
+        return {
+            content: response,
+            personality_elements: {
+                greeting_used: session.messageCount <= 1,
+                characteristic_phrases: personality.characteristic_phrases.slice(0, 2),
+                expertise_demonstrated: personality.expertise_focus.slice(0, 3),
+                communication_style_applied: personality.communication_style
+            },
+            recommendations,
+            response_type: responseType,
+            confidence_level: confidenceLevel
+        };
+    }
+    /**
+     * Generate personality-driven content
+     */
+    async generatePersonalityContent(specialist, personality, userMessage, relevantTopics, context) {
+        // This is where we'd integrate with the actual BC knowledge to generate responses
+        // For now, let's create template-based responses that demonstrate personality
+        const templates = this.getResponseTemplates(specialist.specialist_id);
+        const selectedTemplate = this.selectBestTemplate(templates, userMessage, relevantTopics);
+        if (selectedTemplate) {
+            return this.fillTemplate(selectedTemplate, specialist, userMessage, relevantTopics, context);
+        }
+        // Fallback to basic personality-driven response
+        return this.generateBasicPersonalityResponse(specialist, userMessage, relevantTopics);
+    }
+    /**
+     * Generate a basic personality-driven response
+     */
+    generateBasicPersonalityResponse(specialist, userMessage, relevantTopics) {
+        // Apply specialist's communication style and expertise focus
+        const styleApproach = this.getStyleApproach(specialist);
+        let response = `${styleApproach} `;
+        if (relevantTopics.length > 0) {
+            response += `I can see this relates to ${relevantTopics[0].title}. `;
+            response += this.generateKnowledgeBasedGuidance(specialist, relevantTopics[0], userMessage);
+        }
+        else {
+            response += `While this might be outside my primary expertise in ${specialist.expertise.primary.join(', ')}, `;
+            response += this.generateGeneralGuidance(specialist, userMessage);
+        }
+        return response;
+    }
+    /**
+     * Generate style-appropriate opening
+     */
+    getStyleApproach(specialist) {
+        const communication = specialist.persona.communication_style.toLowerCase();
+        if (communication.includes('technical')) {
+            return "Let's dive into the technical details.";
+        }
+        else if (communication.includes('business')) {
+            return "Let's think about this from a business perspective.";
+        }
+        else if (communication.includes('practical')) {
+            return "Here's a practical approach to your question.";
+        }
+        else if (communication.includes('teaching')) {
+            return "Let me walk you through this step by step.";
+        }
+        return "I'd be happy to help with this!";
+    }
+    /**
+     * Generate knowledge-based guidance
+     */
+    generateKnowledgeBasedGuidance(specialist, topic, userMessage) {
+        // Create specialist-specific framing of the knowledge
+        const specialistLens = this.getSpecialistPerspective(specialist, topic);
+        // Extract key points from the topic content
+        const keyPoints = this.extractKeyGuidancePoints(topic);
+        return `${specialistLens} Looking at **${topic.title}**, ${keyPoints}. This ${topic.frontmatter.difficulty === 'advanced' ? 'advanced' : topic.frontmatter.difficulty} pattern applies directly to your situation.`;
+    }
+    /**
+     * Get specialist-specific perspective on a topic
+     */
+    getSpecialistPerspective(specialist, topic) {
+        const specialistId = specialist.specialist_id;
+        if (specialistId.includes('performance') || specialistId.includes('debug')) {
+            return `From a performance optimization standpoint,`;
+        }
+        else if (specialistId.includes('security')) {
+            return `From a security perspective,`;
+        }
+        else if (specialistId.includes('architect')) {
+            return `From an architectural design perspective,`;
+        }
+        else if (specialistId.includes('test')) {
+            return `From a testing and quality standpoint,`;
+        }
+        else if (specialistId.includes('mentor') || specialistId.includes('docs')) {
+            return `Let me explain this step by step:`;
+        }
+        return `Based on my expertise in ${specialist.expertise.primary[0]},`;
+    }
+    /**
+     * Extract key guidance points from topic content
+     */
+    extractKeyGuidancePoints(topic) {
+        const content = topic.content;
+        // Look for key implementation patterns
+        if (content.includes('## Implementation') || content.includes('## How to')) {
+            return `the key implementation approach focuses on ${this.extractImplementationFocus(content)}`;
+        }
+        // Look for best practices
+        if (content.includes('## Best Practices') || content.includes('### Best Practices')) {
+            return `the best practices emphasize ${this.extractBestPractices(content)}`;
+        }
+        // Look for common pitfalls
+        if (content.includes('## Common Pitfalls') || content.includes('### Pitfalls')) {
+            return `it's important to avoid ${this.extractPitfalls(content)}`;
+        }
+        // Default to title-based guidance
+        return `this pattern provides essential guidance for ${topic.title.toLowerCase()}`;
+    }
+    /**
+     * Extract implementation focus from content
+     */
+    extractImplementationFocus(content) {
+        // Find implementation section and extract first few points
+        const lines = content.split('\n');
+        const implIndex = lines.findIndex(line => line.includes('## Implementation') || line.includes('## How to'));
+        if (implIndex >= 0 && implIndex < lines.length - 1) {
+            const nextFewLines = lines.slice(implIndex + 1, implIndex + 4)
+                .filter(line => line.trim() && !line.startsWith('#'))
+                .join(' ');
+            return this.summarizeIntoPhrase(nextFewLines);
+        }
+        return 'proper implementation patterns';
+    }
+    /**
+     * Extract best practices from content
+     */
+    extractBestPractices(content) {
+        const lines = content.split('\n');
+        const practicesIndex = lines.findIndex(line => line.includes('Best Practices'));
+        if (practicesIndex >= 0 && practicesIndex < lines.length - 1) {
+            const nextFewLines = lines.slice(practicesIndex + 1, practicesIndex + 3)
+                .filter(line => line.trim() && !line.startsWith('#'))
+                .join(' ');
+            return this.summarizeIntoPhrase(nextFewLines);
+        }
+        return 'following established patterns and maintaining code quality';
+    }
+    /**
+     * Extract pitfalls from content
+     */
+    extractPitfalls(content) {
+        const lines = content.split('\n');
+        const pitfallsIndex = lines.findIndex(line => line.includes('Pitfalls') || line.includes('Common Issues'));
+        if (pitfallsIndex >= 0 && pitfallsIndex < lines.length - 1) {
+            const nextFewLines = lines.slice(pitfallsIndex + 1, pitfallsIndex + 3)
+                .filter(line => line.trim() && !line.startsWith('#'))
+                .join(' ');
+            return this.summarizeIntoPhrase(nextFewLines);
+        }
+        return 'common implementation mistakes';
+    }
+    /**
+     * Summarize content into a concise phrase
+     */
+    summarizeIntoPhrase(text) {
+        // Clean up the text and create a concise summary
+        const cleaned = text
+            .replace(/[*#-]/g, '')
+            .replace(/\s+/g, ' ')
+            .trim();
+        // Take first sentence or first 60 characters
+        const firstSentence = cleaned.split('.')[0];
+        const truncated = firstSentence.length > 60
+            ? firstSentence.substring(0, 60) + '...'
+            : firstSentence;
+        return truncated.toLowerCase();
+    }
+    /**
+     * Generate general guidance when no specific topics match
+     */
+    generateGeneralGuidance(specialist, userMessage) {
+        return `I'd suggest we start by understanding the specific requirements and then I can point you toward the right specialist or resources that would be most helpful.`;
+    }
+    // Additional helper methods...
+    initializeResponseTemplates() {
+        // Initialize with basic templates - these could be loaded from configuration
+        this.responseTemplates.set('performance', [
+            {
+                trigger_keywords: ['slow', 'performance', 'optimize', 'speed'],
+                specialist_types: ['dean-debug'],
+                template_pattern: "🔧 Dean here! Performance issues are my specialty. {problem_analysis} {solution_approach} {next_steps}",
+                personality_emphasis: ['technical', 'systematic', 'thorough'],
+                knowledge_domains: ['performance', 'optimization']
+            }
+        ]);
+    }
+    getResponseTemplates(specialistId) {
+        // Return templates relevant to this specialist
+        return Array.from(this.responseTemplates.values()).flat()
+            .filter(template => template.specialist_types.includes(specialistId));
+    }
+    selectBestTemplate(templates, userMessage, relevantTopics) {
+        // Simple keyword matching for now
+        const messageLower = userMessage.toLowerCase();
+        for (const template of templates) {
+            if (template.trigger_keywords.some(keyword => messageLower.includes(keyword))) {
+                return template;
+            }
+        }
+        return null;
+    }
+    fillTemplate(template, specialist, userMessage, relevantTopics, context) {
+        // Basic template filling - would be more sophisticated in practice
+        let content = template.template_pattern;
+        content = content.replace('{problem_analysis}', 'Let me analyze this issue systematically.');
+        content = content.replace('{solution_approach}', 'Here\'s how I\'d approach solving this:');
+        content = content.replace('{next_steps}', 'Next steps would be to examine the specific implementation details.');
+        return content;
+    }
+    extractProblemApproach(specialist) {
+        // Extract problem-solving approach from specialist definition
+        return specialist.persona.communication_style;
+    }
+    extractCollaborationStyle(specialist) {
+        // Extract collaboration preferences
+        return specialist.collaboration?.natural_handoffs?.length > 0 ? 'collaborative' : 'independent';
+    }
+    extractCharacteristicPhrases(specialist) {
+        // Extract characteristic phrases from the content
+        return []; // Would parse from the specialist's content
+    }
+    buildGreeting(specialist, personality, context) {
+        let greeting = specialist.persona.greeting;
+        if (context?.problem) {
+            greeting += ` I understand you're working on ${context.problem}. `;
+        }
+        greeting += ` I'm here to help with ${specialist.expertise.primary.join(', ')}. What specific challenge are you facing?`;
+        return greeting;
+    }
+    buildHandoffFarewell(fromSpecialist, toSpecialist, context) {
+        return `I think ${toSpecialist.persona.greeting.replace('!', '')} would be perfect for this! They're our expert in ${toSpecialist.expertise.primary.join(' and ')}. Let me hand you over to them.`;
+    }
+    buildHandoffIntroduction(toSpecialist, fromSpecialist, context) {
+        return `${toSpecialist.persona.greeting} ${fromSpecialist.specialist_id.split('-')[0]} filled me in on what you're working on. I'm excited to help with ${toSpecialist.expertise.primary[0]}! Let's dive in.`;
+    }
+    async calculateSpecialistConfidence(userMessage, specialist, context) {
+        const messageLower = userMessage.toLowerCase();
+        let confidence = 0;
+        // Check against primary expertise
+        for (const expertise of specialist.expertise.primary) {
+            if (messageLower.includes(expertise.toLowerCase().replace('-', ' '))) {
+                confidence += 0.3;
+            }
+        }
+        // Check against secondary expertise  
+        for (const expertise of specialist.expertise.secondary) {
+            if (messageLower.includes(expertise.toLowerCase().replace('-', ' '))) {
+                confidence += 0.2;
+            }
+        }
+        // Check against domains
+        for (const domain of specialist.domains) {
+            if (messageLower.includes(domain.toLowerCase().replace('-', ' '))) {
+                confidence += 0.1;
+            }
+        }
+        return Math.min(confidence, 1.0);
+    }
+    generateSuggestionReasoning(userMessage, specialist, confidence) {
+        return `${specialist.specialist_id} specializes in ${specialist.expertise.primary.join(', ')} which aligns with your question about ${userMessage.substring(0, 50)}...`;
+    }
+    generateContextUpdates(context, relevantTopics) {
+        return {
+        // Add discovered topics to context
+        // Update problem understanding
+        // Track user preferences
+        };
+    }
+    async suggestCollaborations(context, relevantTopics) {
+        const suggestions = [];
+        // Check if other specialists might be helpful
+        const { specialist } = context;
+        if (specialist.collaboration?.natural_handoffs) {
+            for (const handoffId of specialist.collaboration.natural_handoffs) {
+                suggestions.push({
+                    specialist_id: handoffId,
+                    reason: `Natural collaboration partner for ${specialist.expertise.primary[0]}`
+                });
+            }
+        }
+        return suggestions.slice(0, 2); // Limit suggestions
+    }
+    getApplicationContext(topic, userMessage) {
+        const messageWords = userMessage.toLowerCase().split(' ');
+        const topicTags = topic.frontmatter.tags || [];
+        // Identify context based on user message and topic
+        let context = `Applied ${topic.title} to address`;
+        if (messageWords.some(word => ['performance', 'slow', 'optimize', 'speed'].includes(word))) {
+            context += ` performance concerns in ${this.extractEntityFromMessage(userMessage)}`;
+        }
+        else if (messageWords.some(word => ['security', 'permission', 'access'].includes(word))) {
+            context += ` security requirements for ${this.extractEntityFromMessage(userMessage)}`;
+        }
+        else if (messageWords.some(word => ['integration', 'api', 'connect'].includes(word))) {
+            context += ` integration challenges with ${this.extractEntityFromMessage(userMessage)}`;
+        }
+        else if (messageWords.some(word => ['test', 'testing', 'validation'].includes(word))) {
+            context += ` testing strategy for ${this.extractEntityFromMessage(userMessage)}`;
+        }
+        else {
+            context += ` the development challenge in ${userMessage.substring(0, 50)}...`;
+        }
+        // Add BC version context if available
+        if (topic.frontmatter.bc_versions) {
+            context += ` (BC ${topic.frontmatter.bc_versions} compatible)`;
+        }
+        return context;
+    }
+    /**
+     * Extract business entity or object from user message
+     */
+    extractEntityFromMessage(message) {
+        const commonEntities = [
+            'table', 'page', 'report', 'codeunit', 'api', 'service',
+            'customer', 'vendor', 'item', 'purchase', 'sales', 'inventory'
+        ];
+        const messageLower = message.toLowerCase();
+        for (const entity of commonEntities) {
+            if (messageLower.includes(entity)) {
+                return entity;
+            }
+        }
+        return 'your BC implementation';
+    }
+    generateRecommendations(topics, userMessage) {
+        const recommendations = [];
+        for (const topic of topics.slice(0, 3)) {
+            // Create actionable recommendations based on the topic
+            if (topic.frontmatter.bc_versions) {
+                recommendations.push(`Apply **${topic.title}** patterns (compatible with ${topic.frontmatter.bc_versions})`);
+            }
+            else {
+                recommendations.push(`Consider implementing **${topic.title}** best practices`);
+            }
+            // Add specific action based on topic type
+            if (topic.frontmatter.tags?.includes('performance')) {
+                recommendations.push(`Measure performance impact of ${topic.title.toLowerCase()} implementation`);
+            }
+            else if (topic.frontmatter.tags?.includes('security')) {
+                recommendations.push(`Review security implications when applying ${topic.title.toLowerCase()}`);
+            }
+            else if (topic.frontmatter.tags?.includes('testing')) {
+                recommendations.push(`Create test cases to validate ${topic.title.toLowerCase()} implementation`);
+            }
+        }
+        return recommendations.slice(0, 4); // Limit to 4 recommendations
+    }
+    determineResponseType(userMessage, topics) {
+        const messageLower = userMessage.toLowerCase();
+        if (messageLower.includes('how') || messageLower.includes('help')) {
+            return 'guidance';
+        }
+        else if (messageLower.includes('fix') || messageLower.includes('solve')) {
+            return 'solution';
+        }
+        else if (messageLower.includes('?')) {
+            return 'question';
+        }
+        return 'guidance';
+    }
+    calculateConfidenceLevel(specialist, userMessage, topics) {
+        if (topics.length >= 2)
+            return 'high';
+        if (topics.length === 1)
+            return 'medium';
+        return 'low';
+    }
+}
+/**
+ * Knowledge retriever implementation for BC topics
+ */
+class BCKnowledgeRetriever {
+    layerService;
+    knowledgeService;
+    constructor(layerService, knowledgeService) {
+        this.layerService = layerService;
+        this.knowledgeService = knowledgeService;
+    }
+    async findRelevantTopics(userMessage, specialistExpertise, limit = 5) {
+        try {
+            // Convert specialist expertise to broader search terms that match topic content
+            const broadSearchTerms = specialistExpertise.map(exp => {
+                // Map specific expertise terms to broader, more searchable terms
+                const mappings = {
+                    'performance-analysis': 'performance',
+                    'error-diagnosis': 'error',
+                    'system-monitoring': 'monitoring',
+                    'optimization-implementation': 'optimization',
+                    'query-optimization': 'query performance',
+                    'memory-management': 'memory',
+                    'integration-performance': 'integration',
+                    'user-experience-optimization': 'user experience'
+                };
+                return mappings[exp] || exp.replace('-', ' ');
+            });
+            // Search for topics using the user's message in code_context field
+            const searchParams = {
+                code_context: `${userMessage} ${broadSearchTerms.join(' ')}`, // Combine user message with expertise terms
+                limit,
+                bc_version: 'BC22' // Default - could be made configurable
+            };
+            // Use the existing knowledge service to find relevant topics
+            const searchResults = await this.knowledgeService.searchTopics(searchParams);
+            // Get full topic details for each search result
+            if (searchResults && Array.isArray(searchResults)) {
+                const topics = [];
+                for (const result of searchResults.slice(0, limit)) {
+                    const topic = await this.knowledgeService.getTopic(result.id);
+                    if (topic) {
+                        topics.push(topic);
+                    }
+                }
+                return topics;
+            }
+            return [];
+        }
+        catch (error) {
+            console.error('Error finding relevant topics:', error);
+            return [];
+        }
+    }
+    async getRelatedTopics(topicId, limit = 3) {
+        try {
+            // Get the main topic first
+            const mainTopic = await this.knowledgeService.getTopic(topicId);
+            if (!mainTopic) {
+                return [];
+            }
+            // Use domain-based search to find related topics
+            const searchParams = {
+                query: mainTopic.frontmatter.domain,
+                search_type: 'fuzzy',
+                limit: limit + 1, // Get one extra to exclude the main topic
+                bc_version: 'BC22',
+                domains: [mainTopic.frontmatter.domain]
+            };
+            const searchResults = await this.knowledgeService.searchTopics(searchParams);
+            const relatedTopics = [];
+            for (const result of searchResults) {
+                if (result.id !== topicId && relatedTopics.length < limit) {
+                    const topic = await this.knowledgeService.getTopic(result.id);
+                    if (topic) {
+                        relatedTopics.push(topic);
+                    }
+                }
+            }
+            return relatedTopics;
+        }
+        catch (error) {
+            console.error('Error getting related topics:', error);
+            return [];
+        }
+    }
+    async searchSolutions(problemDescription, domains, limit = 5) {
+        try {
+            // Search for solution-oriented topics in the specified domains
+            const searchParams = {
+                query: `${problemDescription} solution implementation fix pattern`,
+                search_type: 'hybrid',
+                limit: limit * 2, // Get more results to filter
+                bc_version: 'BC22',
+                domains
+            };
+            const searchResults = await this.knowledgeService.searchTopics(searchParams);
+            const solutionTopics = [];
+            for (const result of searchResults) {
+                if (solutionTopics.length >= limit)
+                    break;
+                const topic = await this.knowledgeService.getTopic(result.id);
+                if (topic) {
+                    // Filter for topics that are more solution-oriented
+                    const content = topic.content.toLowerCase();
+                    const title = topic.title.toLowerCase();
+                    if (content.includes('solution') ||
+                        content.includes('implementation') ||
+                        content.includes('fix') ||
+                        content.includes('pattern') ||
+                        title.includes('pattern') ||
+                        title.includes('optimization') ||
+                        title.includes('best practice')) {
+                        solutionTopics.push(topic);
+                    }
+                }
+            }
+            return solutionTopics;
+        }
+        catch (error) {
+            console.error('Error searching solutions:', error);
+            return [];
+        }
+    }
+}
+//# sourceMappingURL=roleplay-engine.js.map