dartmind 17.0.0

package/dist/v10/intent/IntentRouter.js

@@ -0,0 +1,790 @@
+/**
+ * FlutterAI v10 - IntentRouter
+ *
+ * Advanced context-aware intent routing with:
+ * - Context-based route selection
+ * - Multi-intent composition
+ * - Route optimization based on history
+ * - Fallback strategies
+ * - Priority-based routing
+ *
+ * @module v10/intent/IntentRouter
+ */
+import { EventEmitter } from 'events';
+// ============================================================================
+// Default Configuration
+// ============================================================================
+const DEFAULT_CONFIG = {
+    confidenceThreshold: 0.3,
+    maxCompositeHandlers: 5,
+    enableCaching: true,
+    cacheTTL: 60000,
+    historyLimit: 100,
+    enableFallback: true,
+    handlerTimeout: 30000
+};
+// ============================================================================
+// IntentRouter Class
+// ============================================================================
+export class IntentRouter extends EventEmitter {
+    config;
+    handlers;
+    fallbackHandlers;
+    history;
+    cache;
+    stats;
+    routingTimes;
+    constructor(config = {}) {
+        super();
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.handlers = new Map();
+        this.fallbackHandlers = [];
+        this.history = [];
+        this.cache = new Map();
+        this.routingTimes = [];
+        this.stats = {
+            totalRoutes: 0,
+            successfulRoutes: 0,
+            failedRoutes: 0,
+            fallbackUses: 0,
+            cacheHits: 0,
+            cacheMisses: 0,
+            averageRoutingTime: 0,
+            handlerUsage: {},
+            intentDistribution: {}
+        };
+        // Register default handlers
+        this.registerDefaultHandlers();
+    }
+    // --------------------------------------------------------------------------
+    // Handler Registration
+    // --------------------------------------------------------------------------
+    /**
+     * Register a route handler
+     */
+    registerHandler(handler) {
+        this.handlers.set(handler.name, handler);
+        // Sort handlers by priority
+        const sorted = Array.from(this.handlers.values())
+            .sort((a, b) => b.priority - a.priority);
+        this.handlers.clear();
+        for (const h of sorted) {
+            this.handlers.set(h.name, h);
+        }
+    }
+    /**
+     * Unregister a handler
+     */
+    unregisterHandler(name) {
+        this.handlers.delete(name);
+    }
+    /**
+     * Register a fallback handler
+     */
+    registerFallback(handler) {
+        this.fallbackHandlers.push(handler);
+        this.fallbackHandlers.sort((a, b) => b.priority - a.priority);
+    }
+    /**
+     * Get all registered handlers
+     */
+    getHandlers() {
+        return Array.from(this.handlers.values());
+    }
+    // --------------------------------------------------------------------------
+    // Routing
+    // --------------------------------------------------------------------------
+    /**
+     * Route an intent to the appropriate handler
+     */
+    async route(intent, context) {
+        const startTime = Date.now();
+        this.stats.totalRoutes++;
+        this.updateIntentStats(intent);
+        this.emit('router', { type: 'route:started', intent });
+        try {
+            // Build full context
+            const fullContext = this.buildContext(intent, context);
+            // Find matching handler
+            const match = await this.findBestMatch(intent, fullContext);
+            if (!match) {
+                // Try fallback
+                if (this.config.enableFallback) {
+                    return await this.routeToFallback(intent, fullContext, startTime);
+                }
+                return this.createFailedResult('No handler found for intent', startTime);
+            }
+            this.emit('router', {
+                type: 'route:matched',
+                handler: match.handler.name,
+                score: match.score
+            });
+            // Execute handler
+            const result = await this.executeHandler(match.handler, fullContext);
+            // Record history
+            this.recordHistory(intent, match.handler.name, result);
+            // Update stats
+            if (result.success) {
+                this.stats.successfulRoutes++;
+            }
+            else {
+                this.stats.failedRoutes++;
+            }
+            this.updateHandlerStats(match.handler.name);
+            this.updateRoutingTime(Date.now() - startTime);
+            this.emit('router', {
+                type: 'route:completed',
+                handler: match.handler.name,
+                result
+            });
+            return result;
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.stats.failedRoutes++;
+            this.emit('router', { type: 'route:failed', handler: 'unknown', error: err });
+            return this.createFailedResult(err.message, startTime, err);
+        }
+    }
+    /**
+     * Route a composite intent (multi-intent)
+     */
+    async routeComposite(composite, context) {
+        this.emit('router', {
+            type: 'composite:created',
+            intents: [composite.primary.intent, ...composite.secondary.map(s => s.intent)].filter(Boolean)
+        });
+        const results = [];
+        const fullContext = this.buildContext(composite.primary, context);
+        if (composite.order === 'parallel') {
+            // Execute all intents in parallel
+            const promises = [
+                this.route(composite.primary, fullContext),
+                ...composite.secondary.map(intent => this.route(intent, fullContext))
+            ];
+            return Promise.all(promises);
+        }
+        // Sequential execution
+        const primaryResult = await this.route(composite.primary, fullContext);
+        results.push(primaryResult);
+        if (!primaryResult.success && composite.order === 'conditional') {
+            return results;
+        }
+        for (const secondaryIntent of composite.secondary) {
+            // Check condition if exists
+            if (composite.conditions?.has(secondaryIntent.intent || '')) {
+                const condition = composite.conditions.get(secondaryIntent.intent || '');
+                if (!this.evaluateCondition(condition, results)) {
+                    continue;
+                }
+            }
+            const result = await this.route(secondaryIntent, {
+                ...fullContext,
+                history: [...fullContext.history, ...this.getRecentHistory(1)]
+            });
+            results.push(result);
+            if (!result.success && composite.order === 'conditional') {
+                break;
+            }
+        }
+        return results;
+    }
+    /**
+     * Find best matching handler for intent
+     */
+    async findBestMatch(intent, context, criteria) {
+        // Check cache first
+        const cacheKey = this.getCacheKey(intent, criteria);
+        if (this.config.enableCaching) {
+            const cached = this.cache.get(cacheKey);
+            if (cached && cached.expires > Date.now()) {
+                this.stats.cacheHits++;
+                this.emit('router', { type: 'cache:hit', key: cacheKey });
+                return cached.match;
+            }
+            this.stats.cacheMisses++;
+            this.emit('router', { type: 'cache:miss', key: cacheKey });
+        }
+        const matches = [];
+        for (const handler of this.handlers.values()) {
+            const match = this.scoreHandler(handler, intent, context, criteria);
+            if (match.score > 0) {
+                matches.push(match);
+            }
+        }
+        if (matches.length === 0) {
+            return null;
+        }
+        // Sort by score
+        matches.sort((a, b) => b.score - a.score);
+        const bestMatch = matches[0];
+        // Cache result
+        if (this.config.enableCaching) {
+            this.cache.set(cacheKey, {
+                match: bestMatch,
+                expires: Date.now() + this.config.cacheTTL
+            });
+        }
+        return bestMatch;
+    }
+    /**
+     * Find all matching handlers
+     */
+    findAllMatches(intent, context, criteria) {
+        const matches = [];
+        for (const handler of this.handlers.values()) {
+            const match = this.scoreHandler(handler, intent, context, criteria);
+            if (match.score > 0) {
+                matches.push(match);
+            }
+        }
+        return matches.sort((a, b) => b.score - a.score);
+    }
+    // --------------------------------------------------------------------------
+    // Composite Intent Creation
+    // --------------------------------------------------------------------------
+    /**
+     * Create a composite intent from multiple intents
+     */
+    createComposite(primary, secondary, order = 'sequential') {
+        // Calculate combined confidence
+        const allConfidences = [primary.confidence, ...secondary.map(s => s.confidence)];
+        const avgConfidence = allConfidences.reduce((a, b) => a + b, 0) / allConfidences.length;
+        return {
+            primary,
+            secondary: secondary.slice(0, this.config.maxCompositeHandlers - 1),
+            confidence: avgConfidence,
+            order,
+            conditions: new Map()
+        };
+    }
+    /**
+     * Detect if message contains multiple intents
+     */
+    detectMultipleIntents(message) {
+        const intents = [];
+        const lowerMessage = message.toLowerCase();
+        // Look for conjunctions indicating multiple actions
+        const conjunctions = [' and ', ' then ', ' also ', ' additionally ', ' plus '];
+        const parts = [message];
+        for (const conj of conjunctions) {
+            const newParts = [];
+            for (const part of parts) {
+                newParts.push(...part.split(conj));
+            }
+            parts.length = 0;
+            parts.push(...newParts);
+        }
+        // Extract intent from each part
+        for (const part of parts) {
+            const intent = this.extractIntentFromPart(part.trim());
+            if (intent && !intents.includes(intent)) {
+                intents.push(intent);
+            }
+        }
+        return intents;
+    }
+    // --------------------------------------------------------------------------
+    // Context-Aware Routing
+    // --------------------------------------------------------------------------
+    /**
+     * Get routing suggestions based on context
+     */
+    getSuggestions(context) {
+        const suggestions = [];
+        // Based on current file type
+        if (context.currentFile) {
+            const ext = context.currentFile.split('.').pop()?.toLowerCase();
+            if (ext === 'dart') {
+                suggestions.push('Run flutter analyze');
+                suggestions.push('Generate widget test');
+                suggestions.push('Extract widget');
+            }
+            else if (ext === 'ts' || ext === 'tsx') {
+                suggestions.push('Run TypeScript compiler');
+                suggestions.push('Generate unit test');
+                suggestions.push('Extract component');
+            }
+        }
+        // Based on recent history
+        const recentIntents = this.getRecentHistory(5).map(h => h.intent.intent);
+        if (recentIntents.includes('fix')) {
+            suggestions.push('Run tests to verify fix');
+        }
+        if (recentIntents.includes('refactor')) {
+            suggestions.push('Review changes');
+            suggestions.push('Run linter');
+        }
+        // Based on errors in history
+        const recentFailures = this.getRecentHistory(10).filter(h => !h.success);
+        if (recentFailures.length > 2) {
+            suggestions.push('Try a different approach');
+            suggestions.push('Ask for help');
+        }
+        return suggestions;
+    }
+    /**
+     * Optimize route based on history
+     */
+    optimizeRoute(intent, context) {
+        // Look for similar intents in history
+        const similarHistory = this.history.filter(h => h.intent.intent === intent.intent &&
+            h.success);
+        if (similarHistory.length === 0) {
+            return intent;
+        }
+        // Boost confidence if this intent pattern has succeeded before
+        const successRate = similarHistory.filter(h => h.success).length / similarHistory.length;
+        const optimized = { ...intent };
+        optimized.confidence = Math.min(1, intent.confidence + (successRate * 0.2));
+        // Add successful parameters from history
+        for (const entry of similarHistory) {
+            for (const [key, value] of Object.entries(entry.intent.parameters)) {
+                if (!optimized.parameters[key]) {
+                    optimized.parameters[key] = value;
+                }
+            }
+        }
+        return optimized;
+    }
+    // --------------------------------------------------------------------------
+    // Handler Execution
+    // --------------------------------------------------------------------------
+    /**
+     * Execute a handler with timeout
+     */
+    async executeHandler(handler, context) {
+        const startTime = Date.now();
+        return new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                resolve({
+                    success: false,
+                    error: new Error(`Handler timed out after ${this.config.handlerTimeout}ms`),
+                    filesModified: [],
+                    suggestions: [],
+                    executionTime: this.config.handlerTimeout,
+                    metadata: { timeout: true }
+                });
+            }, this.config.handlerTimeout);
+            handler.handle(context)
+                .then(result => {
+                clearTimeout(timeout);
+                resolve({
+                    ...result,
+                    executionTime: Date.now() - startTime
+                });
+            })
+                .catch(error => {
+                clearTimeout(timeout);
+                resolve({
+                    success: false,
+                    error: error instanceof Error ? error : new Error(String(error)),
+                    filesModified: [],
+                    suggestions: [],
+                    executionTime: Date.now() - startTime,
+                    metadata: {}
+                });
+            });
+        });
+    }
+    /**
+     * Route to fallback handler
+     */
+    async routeToFallback(intent, context, startTime) {
+        for (const fallback of this.fallbackHandlers) {
+            try {
+                this.stats.fallbackUses++;
+                this.emit('router', { type: 'route:fallback', handler: fallback.name });
+                const result = await this.executeHandler(fallback, context);
+                this.recordHistory(intent, fallback.name, result);
+                return result;
+            }
+            catch {
+                continue;
+            }
+        }
+        return this.createFailedResult('No fallback handler available', startTime);
+    }
+    // --------------------------------------------------------------------------
+    // Scoring
+    // --------------------------------------------------------------------------
+    /**
+     * Score how well a handler matches an intent
+     */
+    scoreHandler(handler, intent, context, criteria) {
+        let score = 0;
+        const reasons = [];
+        const missingCapabilities = [];
+        // Check intent match
+        if (intent.intent && handler.intents.includes(intent.intent)) {
+            score += 0.5;
+            reasons.push(`Intent match: ${intent.intent}`);
+        }
+        else if (handler.intents.includes('*')) {
+            score += 0.2;
+            reasons.push('Wildcard handler');
+        }
+        // Check confidence threshold
+        if (criteria?.minConfidence && intent.confidence < criteria.minConfidence) {
+            score = 0;
+            reasons.push(`Confidence too low: ${intent.confidence}`);
+        }
+        else if (intent.confidence >= this.config.confidenceThreshold) {
+            score += intent.confidence * 0.3;
+            reasons.push(`Confidence: ${intent.confidence.toFixed(2)}`);
+        }
+        // Check capabilities
+        for (const cap of handler.capabilities) {
+            if (context.capabilities.has(cap)) {
+                score += 0.1;
+            }
+            else {
+                missingCapabilities.push(cap);
+                score -= 0.05;
+            }
+        }
+        // Check criteria
+        if (criteria) {
+            if (criteria.capabilities) {
+                const hasAll = criteria.capabilities.every(c => handler.capabilities.includes(c) || context.capabilities.has(c));
+                if (!hasAll) {
+                    score = 0;
+                }
+            }
+            if (criteria.maxTime && handler.estimatedTime > criteria.maxTime) {
+                score *= 0.5;
+                reasons.push('Exceeds time limit');
+            }
+            if (criteria.composable !== undefined && handler.composable !== criteria.composable) {
+                score *= 0.8;
+            }
+        }
+        // Boost score based on history
+        const historyBoost = this.getHistoryBoost(handler.name, intent);
+        score += historyBoost;
+        if (historyBoost > 0) {
+            reasons.push(`History boost: +${historyBoost.toFixed(2)}`);
+        }
+        return {
+            handler,
+            score: Math.max(0, Math.min(1, score)),
+            reason: reasons.join('; '),
+            missingCapabilities,
+            estimatedTime: handler.estimatedTime
+        };
+    }
+    /**
+     * Get score boost from history
+     */
+    getHistoryBoost(handlerName, intent) {
+        const recentUses = this.history
+            .slice(-20)
+            .filter(h => h.handler === handlerName && h.intent.intent === intent.intent);
+        if (recentUses.length === 0)
+            return 0;
+        const successRate = recentUses.filter(h => h.success).length / recentUses.length;
+        return successRate * 0.1;
+    }
+    // --------------------------------------------------------------------------
+    // Helper Methods
+    // --------------------------------------------------------------------------
+    /**
+     * Build full route context
+     */
+    buildContext(intent, partial) {
+        return {
+            message: intent.rawInput,
+            intent,
+            currentFile: partial.currentFile,
+            selection: partial.selection,
+            projectRoot: partial.projectRoot || process.cwd(),
+            history: partial.history || this.getRecentHistory(10),
+            variables: partial.variables || new Map(),
+            capabilities: partial.capabilities || new Set(['read', 'write', 'execute']),
+            preferences: partial.preferences || {}
+        };
+    }
+    /**
+     * Get recent history entries
+     */
+    getRecentHistory(count) {
+        return this.history.slice(-count);
+    }
+    /**
+     * Record a routing to history
+     */
+    recordHistory(intent, handler, result) {
+        this.history.push({
+            timestamp: new Date(),
+            intent,
+            handler,
+            success: result.success,
+            files: result.filesModified
+        });
+        // Trim history
+        if (this.history.length > this.config.historyLimit) {
+            this.history = this.history.slice(-this.config.historyLimit);
+        }
+    }
+    /**
+     * Create cache key for intent
+     */
+    getCacheKey(intent, criteria) {
+        const parts = [
+            intent.intent || 'unknown',
+            intent.category,
+            intent.target || 'no-target'
+        ];
+        if (criteria) {
+            parts.push(JSON.stringify(criteria));
+        }
+        return parts.join(':');
+    }
+    /**
+     * Extract intent from message part
+     */
+    extractIntentFromPart(part) {
+        const lowerPart = part.toLowerCase();
+        const intentKeywords = {
+            fix: ['fix', 'repair', 'solve', 'resolve', 'debug'],
+            refactor: ['refactor', 'restructure', 'reorganize', 'clean'],
+            add: ['add', 'create', 'new', 'implement', 'build'],
+            remove: ['remove', 'delete', 'drop', 'eliminate'],
+            update: ['update', 'change', 'modify', 'edit'],
+            explain: ['explain', 'describe', 'what', 'how'],
+            find: ['find', 'search', 'locate', 'where'],
+            analyze: ['analyze', 'review', 'check', 'inspect'],
+            test: ['test', 'verify', 'validate'],
+            document: ['document', 'comment', 'annotate']
+        };
+        for (const [intent, keywords] of Object.entries(intentKeywords)) {
+            if (keywords.some(kw => lowerPart.includes(kw))) {
+                return intent;
+            }
+        }
+        return null;
+    }
+    /**
+     * Evaluate a condition string
+     */
+    evaluateCondition(condition, results) {
+        // Simple condition evaluation
+        if (condition === 'previous_success') {
+            return results.length > 0 && results[results.length - 1].success;
+        }
+        if (condition === 'previous_failure') {
+            return results.length > 0 && !results[results.length - 1].success;
+        }
+        if (condition === 'any_success') {
+            return results.some(r => r.success);
+        }
+        if (condition === 'all_success') {
+            return results.every(r => r.success);
+        }
+        return true;
+    }
+    /**
+     * Create a failed result
+     */
+    createFailedResult(message, startTime, error) {
+        return {
+            success: false,
+            error: error || new Error(message),
+            filesModified: [],
+            suggestions: [],
+            executionTime: Date.now() - startTime,
+            metadata: {}
+        };
+    }
+    /**
+     * Update intent statistics
+     */
+    updateIntentStats(intent) {
+        const key = intent.intent || 'unknown';
+        this.stats.intentDistribution[key] = (this.stats.intentDistribution[key] || 0) + 1;
+    }
+    /**
+     * Update handler usage statistics
+     */
+    updateHandlerStats(handlerName) {
+        this.stats.handlerUsage[handlerName] = (this.stats.handlerUsage[handlerName] || 0) + 1;
+    }
+    /**
+     * Update routing time statistics
+     */
+    updateRoutingTime(time) {
+        this.routingTimes.push(time);
+        if (this.routingTimes.length > 100) {
+            this.routingTimes.shift();
+        }
+        this.stats.averageRoutingTime =
+            this.routingTimes.reduce((a, b) => a + b, 0) / this.routingTimes.length;
+    }
+    // --------------------------------------------------------------------------
+    // Default Handlers
+    // --------------------------------------------------------------------------
+    /**
+     * Register default handlers
+     */
+    registerDefaultHandlers() {
+        // Fix handler
+        this.registerHandler({
+            name: 'FixHandler',
+            description: 'Fix bugs and errors in code',
+            intents: ['fix'],
+            priority: 90,
+            composable: true,
+            capabilities: ['read', 'write'],
+            estimatedTime: 5000,
+            handle: async (ctx) => ({
+                success: true,
+                response: `Would fix: ${ctx.intent.target || ctx.currentFile || 'code'}`,
+                filesModified: ctx.currentFile ? [ctx.currentFile] : [],
+                suggestions: ['Run tests', 'Review changes'],
+                executionTime: 0,
+                metadata: { handler: 'FixHandler' }
+            })
+        });
+        // Refactor handler
+        this.registerHandler({
+            name: 'RefactorHandler',
+            description: 'Refactor and restructure code',
+            intents: ['refactor', 'extract', 'inline'],
+            priority: 80,
+            composable: true,
+            capabilities: ['read', 'write'],
+            estimatedTime: 10000,
+            handle: async (ctx) => ({
+                success: true,
+                response: `Would refactor: ${ctx.intent.target || ctx.currentFile || 'code'}`,
+                filesModified: ctx.currentFile ? [ctx.currentFile] : [],
+                suggestions: ['Run tests', 'Run linter'],
+                executionTime: 0,
+                metadata: { handler: 'RefactorHandler' }
+            })
+        });
+        // Explain handler
+        this.registerHandler({
+            name: 'ExplainHandler',
+            description: 'Explain code functionality',
+            intents: ['explain', 'trace'],
+            priority: 70,
+            composable: false,
+            capabilities: ['read'],
+            estimatedTime: 3000,
+            handle: async (ctx) => ({
+                success: true,
+                response: `Explanation of: ${ctx.intent.target || ctx.currentFile || 'code'}`,
+                filesModified: [],
+                suggestions: [],
+                executionTime: 0,
+                metadata: { handler: 'ExplainHandler' }
+            })
+        });
+        // Find handler
+        this.registerHandler({
+            name: 'FindHandler',
+            description: 'Find code and files',
+            intents: ['find'],
+            priority: 70,
+            composable: true,
+            capabilities: ['read'],
+            estimatedTime: 2000,
+            handle: async (ctx) => ({
+                success: true,
+                response: `Search results for: ${ctx.intent.parameters.query || ctx.intent.rawInput}`,
+                filesModified: [],
+                suggestions: ['Refine search', 'Open file'],
+                executionTime: 0,
+                metadata: { handler: 'FindHandler' }
+            })
+        });
+        // Add handler
+        this.registerHandler({
+            name: 'AddHandler',
+            description: 'Add new code or features',
+            intents: ['add'],
+            priority: 85,
+            composable: true,
+            capabilities: ['read', 'write'],
+            estimatedTime: 8000,
+            handle: async (ctx) => ({
+                success: true,
+                response: `Would add: ${ctx.intent.target || 'new code'}`,
+                filesModified: ctx.currentFile ? [ctx.currentFile] : [],
+                suggestions: ['Run tests', 'Review implementation'],
+                executionTime: 0,
+                metadata: { handler: 'AddHandler' }
+            })
+        });
+        // Generic fallback
+        this.registerFallback({
+            name: 'GenericFallback',
+            description: 'Generic handler for unmatched intents',
+            intents: ['*'],
+            priority: 0,
+            composable: false,
+            capabilities: [],
+            estimatedTime: 1000,
+            handle: async (ctx) => ({
+                success: true,
+                response: `Processing: ${ctx.intent.rawInput}`,
+                filesModified: [],
+                suggestions: ['Try being more specific', 'Use help command'],
+                executionTime: 0,
+                metadata: { handler: 'GenericFallback', fallback: true }
+            })
+        });
+    }
+    // --------------------------------------------------------------------------
+    // Statistics & Cache
+    // --------------------------------------------------------------------------
+    /**
+     * Get router statistics
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Reset statistics
+     */
+    resetStats() {
+        this.stats = {
+            totalRoutes: 0,
+            successfulRoutes: 0,
+            failedRoutes: 0,
+            fallbackUses: 0,
+            cacheHits: 0,
+            cacheMisses: 0,
+            averageRoutingTime: 0,
+            handlerUsage: {},
+            intentDistribution: {}
+        };
+        this.routingTimes = [];
+    }
+    /**
+     * Clear cache
+     */
+    clearCache() {
+        this.cache.clear();
+    }
+    /**
+     * Clear history
+     */
+    clearHistory() {
+        this.history = [];
+    }
+    /**
+     * Get configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(updates) {
+        this.config = { ...this.config, ...updates };
+    }
+}
+//# sourceMappingURL=IntentRouter.js.map