Add AI NLP and router modules for advanced natural language processing

- Introduced comprehensive NLP processing modules for intent classification, entity extraction, and context analysis
- Created AI router with rate-limited endpoints for command interpretation and execution
- Added prompt templates for different AI models with configurable system and user prompts
- Implemented robust type definitions for AI-related interfaces and schemas
- Enhanced security and error handling in AI processing pipeline

src/ai/nlp/context-analyzer.ts

@@ -0,0 +1,135 @@
+import { AIContext, AIIntent } from '../types/index.js';
+
+interface ContextAnalysis {
+    confidence: number;
+    relevant_params: Record<string, any>;
+}
+
+interface ContextRule {
+    condition: (context: AIContext, intent: AIIntent) => boolean;
+    relevance: number;
+    params?: (context: AIContext) => Record<string, any>;
+}
+
+export class ContextAnalyzer {
+    private contextRules: ContextRule[];
+
+    constructor() {
+        this.contextRules = [
+            // Location-based context
+            {
+                condition: (context, intent) =>
+                    Boolean(context.location && intent.target.includes(context.location.toLowerCase())),
+                relevance: 0.8,
+                params: (context) => ({ location: context.location })
+            },
+
+            // Time-based context
+            {
+                condition: (context) => {
+                    const hour = new Date(context.timestamp).getHours();
+                    return hour >= 0 && hour <= 23;
+                },
+                relevance: 0.6,
+                params: (context) => ({
+                    time_of_day: this.getTimeOfDay(new Date(context.timestamp))
+                })
+            },
+
+            // Previous action context
+            {
+                condition: (context, intent) => {
+                    const recentActions = context.previous_actions.slice(-3);
+                    return recentActions.some(action =>
+                        action.target === intent.target ||
+                        action.action === intent.action
+                    );
+                },
+                relevance: 0.7,
+                params: (context) => ({
+                    recent_action: context.previous_actions[context.previous_actions.length - 1]
+                })
+            },
+
+            // Environment state context
+            {
+                condition: (context, intent) => {
+                    return Object.keys(context.environment_state).some(key =>
+                        intent.target.includes(key) ||
+                        intent.parameters[key] !== undefined
+                    );
+                },
+                relevance: 0.9,
+                params: (context) => ({ environment: context.environment_state })
+            }
+        ];
+    }
+
+    async analyze(intent: AIIntent, context: AIContext): Promise<ContextAnalysis> {
+        let totalConfidence = 0;
+        let relevantParams: Record<string, any> = {};
+        let applicableRules = 0;
+
+        for (const rule of this.contextRules) {
+            if (rule.condition(context, intent)) {
+                totalConfidence += rule.relevance;
+                applicableRules++;
+
+                if (rule.params) {
+                    relevantParams = {
+                        ...relevantParams,
+                        ...rule.params(context)
+                    };
+                }
+            }
+        }
+
+        // Calculate normalized confidence
+        const confidence = applicableRules > 0
+            ? totalConfidence / applicableRules
+            : 0.5; // Default confidence if no rules apply
+
+        return {
+            confidence,
+            relevant_params: relevantParams
+        };
+    }
+
+    private getTimeOfDay(date: Date): string {
+        const hour = date.getHours();
+
+        if (hour >= 5 && hour < 12) return 'morning';
+        if (hour >= 12 && hour < 17) return 'afternoon';
+        if (hour >= 17 && hour < 22) return 'evening';
+        return 'night';
+    }
+
+    async updateContextRules(newRules: ContextRule[]): Promise<void> {
+        this.contextRules = [...this.contextRules, ...newRules];
+    }
+
+    async validateContext(context: AIContext): Promise<boolean> {
+        // Validate required context fields
+        if (!context.timestamp || !context.user_id || !context.session_id) {
+            return false;
+        }
+
+        // Validate timestamp format
+        const timestamp = new Date(context.timestamp);
+        if (isNaN(timestamp.getTime())) {
+            return false;
+        }
+
+        // Validate previous actions array
+        if (!Array.isArray(context.previous_actions)) {
+            return false;
+        }
+
+        // Validate environment state
+        if (typeof context.environment_state !== 'object' || context.environment_state === null) {
+            return false;
+        }
+
+        return true;
+    }
+}