Source: prompts/compatibility.js

/**
 * Compatibility layer for existing prompt systems
 * 
 * This module provides adapters and wrappers to ensure existing code
 * continues to work while gradually migrating to the unified system.
 */

import PromptManager from './PromptManager.js';
import { createPromptContext, createPromptOptions } from './interfaces.js';
import logger from 'loglevel';

// Global prompt manager instance
let globalPromptManager = null;
let templatesLoadedPromise = null;

/**
 * Get or create global prompt manager
 */
function getPromptManager(options = {}) {
    if (!globalPromptManager) {
        globalPromptManager = new PromptManager({
            enableLegacySupport: true,
            cacheTemplates: true,
            ...options
        });
        
        // Load external templates asynchronously
        templatesLoadedPromise = globalPromptManager.loadExternalTemplates()
            .catch(error => {
                logger.error('Failed to load external templates in compatibility layer:', error.message);
                // Continue operation with basic templates only
            });
    }
    return globalPromptManager;
}

/**
 * PromptTemplates compatibility wrapper
 * Maintains the exact same API as the original PromptTemplates class
 */
export class PromptTemplatesCompat {
    static templates = {
        // Legacy templates maintained for compatibility
        'llama2': {
            chat: (system, context, query) => {
                const manager = getPromptManager();
                const adapter = manager.getLegacyAdapter('PromptTemplates');
                return adapter.formatChatPrompt('llama2', system, context, query);
            },
            completion: (context, query) => {
                const manager = getPromptManager();
                const adapter = manager.getLegacyAdapter('PromptTemplates');
                return adapter.formatCompletionPrompt('llama2', context, query);
            },
            extractConcepts: (text) => {
                const manager = getPromptManager();
                const adapter = manager.getLegacyAdapter('PromptTemplates');
                return adapter.formatConceptPrompt('llama2', text);
            }
        },
        'mistral': {
            chat: (system, context, query) => {
                const manager = getPromptManager();
                const adapter = manager.getLegacyAdapter('PromptTemplates');
                return adapter.formatChatPrompt('mistral', system, context, query);
            },
            completion: (context, query) => {
                const manager = getPromptManager();
                const adapter = manager.getLegacyAdapter('PromptTemplates');
                return adapter.formatCompletionPrompt('mistral', context, query);
            },
            extractConcepts: (text) => {
                const manager = getPromptManager();
                const adapter = manager.getLegacyAdapter('PromptTemplates');
                return adapter.formatConceptPrompt('mistral', text);
            }
        }
    };

    static getTemplateForModel(modelName) {
        const manager = getPromptManager();
        const adapter = manager.getLegacyAdapter('PromptTemplates');
        return adapter.getTemplateForModel(modelName);
    }

    static formatChatPrompt(modelName, system, context, query) {
        const manager = getPromptManager();
        const adapter = manager.getLegacyAdapter('PromptTemplates');
        return adapter.formatChatPrompt(modelName, system, context, query);
    }

    static formatCompletionPrompt(modelName, context, query) {
        const manager = getPromptManager();
        const adapter = manager.getLegacyAdapter('PromptTemplates');
        return adapter.formatCompletionPrompt(modelName, context, query);
    }

    static formatConceptPrompt(modelName, text) {
        const manager = getPromptManager();
        const adapter = manager.getLegacyAdapter('PromptTemplates');
        return adapter.formatConceptPrompt(modelName, text);
    }

    static registerTemplate(modelName, template) {
        const manager = getPromptManager();
        
        // Convert legacy template to unified format
        const unifiedTemplate = {
            name: modelName,
            description: `Template for ${modelName}`,
            content: template.chat ? '${query}' : template,
            format: 'chat',
            supportedModels: [modelName]
        };
        
        manager.registerTemplate(unifiedTemplate);
        
        // Update legacy templates
        this.templates[modelName.toLowerCase()] = template;
    }
}

/**
 * PromptFormatter compatibility wrapper
 */
export class PromptFormatterCompat {
    constructor(options = {}) {
        this.config = options;
        this.manager = getPromptManager();
    }

    async format(projectedContent, navigationContext, options = {}) {
        const adapter = this.manager.getLegacyAdapter('PromptFormatter');
        return await adapter.format(projectedContent, navigationContext, options);
    }

    async formatAsStructured(context, options) {
        return await this.manager.formatStructured(context, {}, options);
    }

    async formatAsConversational(context, options) {
        return await this.manager.formatConversational(context, {}, options);
    }

    async formatAsJSON(context, options) {
        return await this.manager.formatJSON(context, {}, options);
    }

    async formatAsMarkdown(context, options) {
        return await this.manager.formatMarkdown(context, {}, options);
    }

    async formatAsAnalytical(context, options) {
        // Map to structured format for now
        return await this.manager.formatStructured(context, {}, options);
    }

    getAvailableFormats() {
        return ['structured', 'conversational', 'json', 'markdown', 'analytical'];
    }
}

/**
 * MCP prompts compatibility wrapper
 */
export class MCPPromptsCompat {
    constructor() {
        this.manager = getPromptManager();
    }

    async executePromptWorkflow(prompt, args, toolExecutor) {
        const adapter = this.manager.getLegacyAdapter('MCP');
        return await adapter.executePromptWorkflow(prompt, args, toolExecutor);
    }

    validatePromptArguments(prompt, providedArgs) {
        const adapter = this.manager.getLegacyAdapter('MCP');
        return adapter.validatePromptArguments(prompt, providedArgs);
    }

    listPrompts() {
        return this.manager.listTemplates().filter(t => t.isWorkflow);
    }

    getPrompt(name) {
        return this.manager.getTemplate(name);
    }
}

/**
 * Migration helpers
 */
export class MigrationHelper {
    static async migratePromptTemplates(originalPromptTemplates) {
        const manager = getPromptManager();
        await manager.loadTemplatesFromPromptTemplates(originalPromptTemplates);
        logger.info('Migrated PromptTemplates to unified system');
    }

    static async migrateMCPRegistry(mcpRegistry) {
        const manager = getPromptManager();
        await manager.loadTemplatesFromMCP(mcpRegistry);
        logger.info('Migrated MCP registry to unified system');
    }

    static createContextFromLegacy(system, context, query, model) {
        return createPromptContext({
            systemPrompt: system,
            context: context,
            query: query,
            model: model
        });
    }

    static createOptionsFromLegacy(options) {
        return createPromptOptions({
            format: options.format || 'structured',
            temperature: options.temperature,
            maxTokens: options.maxTokens,
            includeMetadata: options.includeMetadata,
            includeInstructions: options.includeInstructions
        });
    }
}

/**
 * Gradual migration utilities
 */
export class GradualMigration {
    static wrapLLMHandler(originalHandler) {
        return new Proxy(originalHandler, {
            get(target, prop) {
                if (prop === 'generateResponse') {
                    return async function(prompt, context, options = {}) {
                        // Check if unified system should be used
                        if (options.useUnifiedSystem) {
                            const manager = getPromptManager();
                            const promptContext = createPromptContext({
                                query: prompt,
                                context: context,
                                model: this.chatModel,
                                temperature: options.temperature || this.temperature
                            });
                            
                            const promptOptions = createPromptOptions({
                                format: 'chat',
                                ...options
                            });
                            
                            const result = await manager.generatePrompt('default-chat', promptContext, promptOptions);
                            return result.content;
                        }
                        
                        // Fall back to original implementation
                        return await target[prop].call(this, prompt, context, options);
                    };
                }
                
                return target[prop];
            }
        });
    }

    static wrapContextManager(originalManager) {
        return new Proxy(originalManager, {
            get(target, prop) {
                if (prop === 'formatContext') {
                    return function(context, options = {}) {
                        // Check if unified system should be used
                        if (options.useUnifiedSystem) {
                            const manager = getPromptManager();
                            const promptContext = createPromptContext({
                                context: context,
                                ...options
                            });
                            
                            return manager.formatStructured({ content: context }, promptContext, options);
                        }
                        
                        // Fall back to original implementation
                        return target[prop].call(this, context, options);
                    };
                }
                
                return target[prop];
            }
        });
    }
}

/**
 * Feature flags for gradual rollout
 */
export class FeatureFlags {
    static flags = {
        useUnifiedPromptSystem: false,
        enablePromptCaching: true,
        validateTemplates: true,
        logPromptMetrics: false
    };

    static isEnabled(flagName) {
        return this.flags[flagName] === true;
    }

    static enable(flagName) {
        this.flags[flagName] = true;
        logger.info(`Feature flag enabled: ${flagName}`);
    }

    static disable(flagName) {
        this.flags[flagName] = false;
        logger.info(`Feature flag disabled: ${flagName}`);
    }

    static configure(flags) {
        this.flags = { ...this.flags, ...flags };
        logger.info('Feature flags configured:', this.flags);
    }
}

/**
 * Monitoring and metrics
 */
export class PromptMetrics {
    static metrics = {
        legacyCallsTotal: 0,
        unifiedCallsTotal: 0,
        migrationProgress: 0,
        errorRate: 0,
        performanceGain: 0
    };

    static recordLegacyCall(method) {
        this.metrics.legacyCallsTotal++;
        logger.debug(`Legacy call: ${method}`);
    }

    static recordUnifiedCall(method) {
        this.metrics.unifiedCallsTotal++;
        logger.debug(`Unified call: ${method}`);
    }

    static calculateMigrationProgress() {
        const total = this.metrics.legacyCallsTotal + this.metrics.unifiedCallsTotal;
        if (total === 0) return 0;
        return (this.metrics.unifiedCallsTotal / total) * 100;
    }

    static getReport() {
        return {
            ...this.metrics,
            migrationProgress: this.calculateMigrationProgress()
        };
    }
}

/**
 * Export compatibility instances
 */
export const PromptTemplates = PromptTemplatesCompat;
export const PromptFormatter = PromptFormatterCompat;
export const MCPPrompts = MCPPromptsCompat;

// Export manager for direct access
export { getPromptManager };

// Default export for easy importing
export default {
    PromptTemplates: PromptTemplatesCompat,
    PromptFormatter: PromptFormatterCompat,
    MCPPrompts: MCPPromptsCompat,
    MigrationHelper,
    GradualMigration,
    FeatureFlags,
    PromptMetrics,
    getPromptManager
};