bc-code-intelligence-mcp/dist/types/roleplay-types.d.ts

BC Code Intelligence MCP Server - Complete Specialist Bundle with AI-driven expert consultation, seamless handoffs, and context-preserving workflows

/**
 * Roleplay Engine Types
 *
 * Defines interfaces for personality-driven specialist interactions,
 * ensuring consistent character adoption and contextual responses.
 */
import { SpecialistDefinition } from '../services/specialist-loader.js';
import { SpecialistSession, SessionContext } from './session-types.js';
import { AtomicTopic } from './bc-knowledge.js';
/**
 * Context for generating specialist responses
 */
export interface RoleplayContext {
    session: SpecialistSession;
    specialist: SpecialistDefinition;
    userMessage: string;
    conversationHistory: string[];
    requiresIntroduction?: boolean;
    relevantTopics?: AtomicTopic[];
    codeContext?: {
        files: string[];
        codeSnippets: string[];
        bcObjects: string[];
    };
    problemType?: string;
    urgency?: 'low' | 'medium' | 'high';
    complexity?: 'simple' | 'moderate' | 'complex';
}
/**
 * Personality traits that drive response generation
 */
export interface PersonalityTraits {
    communication_style: string;
    expertise_focus: string[];
    problem_approach: string;
    collaboration_style: string;
    characteristic_phrases: string[];
}
/**
 * Generated specialist response with metadata
 */
export interface SpecialistResponse {
    content: string;
    specialist_id: string;
    personality_elements: {
        greeting_used: boolean;
        characteristic_phrases: string[];
        expertise_demonstrated: string[];
        communication_style_applied: string;
    };
    topics_referenced: string[];
    knowledge_applied: {
        topic_id: string;
        application_context: string;
    }[];
    suggested_handoffs?: {
        specialist_id: string;
        reason: string;
    }[];
    context_updates?: Partial<SessionContext> & {
        methodology_suggested?: boolean;
    };
    recommendations_added?: string[];
    response_type: 'guidance' | 'solution' | 'question' | 'handoff' | 'encouragement' | 'methodology_onboarding' | 'methodology_suggestion' | 'direct_specialist_response';
    confidence_level: 'high' | 'medium' | 'low';
}
/**
 * Template for specialist response patterns
 */
export interface ResponseTemplate {
    trigger_keywords: string[];
    specialist_types: string[];
    template_pattern: string;
    personality_emphasis: string[];
    knowledge_domains: string[];
}
/**
 * Configuration for roleplay behavior
 */
export interface RoleplayConfig {
    personality_strength: 'subtle' | 'moderate' | 'strong';
    response_length: 'concise' | 'detailed' | 'adaptive';
    knowledge_integration: 'minimal' | 'balanced' | 'comprehensive';
    suggest_handoffs: boolean;
    suggest_collaborations: boolean;
    learn_user_preferences: boolean;
    adapt_communication_style: boolean;
}
/**
 * Main roleplay engine interface
 */
export interface RoleplayEngine {
    /**
     * Generate a personality-driven response from a specialist
     */
    generateResponse(context: RoleplayContext): Promise<SpecialistResponse>;
    /**
     * Analyze user message to suggest appropriate specialist
     */
    suggestSpecialist(userMessage: string, currentContext?: SessionContext): Promise<{
        specialist_id: string;
        confidence: number;
        reasoning: string;
    }[]>;
    /**
     * Generate a specialist greeting for session start
     */
    generateGreeting(specialist: SpecialistDefinition, context?: Partial<SessionContext>): Promise<SpecialistResponse>;
    /**
     * Generate handoff message when transferring between specialists
     */
    generateHandoff(fromSpecialist: SpecialistDefinition, toSpecialist: SpecialistDefinition, context: RoleplayContext): Promise<{
        farewell: SpecialistResponse;
        introduction: SpecialistResponse;
    }>;
    /**
     * Update configuration
     */
    updateConfig(config: Partial<RoleplayConfig>): void;
    /**
     * Get personality analysis for a specialist
     */
    analyzePersonality(specialist: SpecialistDefinition): PersonalityTraits;
}
/**
 * Knowledge retrieval interface for context-aware responses
 */
export interface KnowledgeRetriever {
    /**
     * Find relevant topics based on user message and specialist expertise
     */
    findRelevantTopics(userMessage: string, specialistExpertise: string[], limit?: number): Promise<AtomicTopic[]>;
    /**
     * Find relevant topics within methodology context
     */
    findRelevantTopicsInMethodology(userMessage: string, methodologyContext: any, specialistExpertise: string[], limit?: number): Promise<AtomicTopic[]>;
    /**
     * Get related topics for deeper context
     */
    getRelatedTopics(topicId: string, limit?: number): Promise<AtomicTopic[]>;
    /**
     * Search for solutions in specialist's domain
     */
    searchSolutions(problemDescription: string, domains: string[], limit?: number): Promise<AtomicTopic[]>;
}
/**
 * Response quality metrics for evaluation and improvement
 */
export interface ResponseMetrics {
    personality_score: number;
    relevance_score: number;
    knowledge_score: number;
    helpfulness_score: number;
    consistency_score: number;
}
//# sourceMappingURL=roleplay-types.d.ts.map