feat: Add comprehensive enhancement modules for Stack 2.9

- NLP: Intent detection, entity recognition, contextual embeddings
- Knowledge Graph: NetworkX-based graph with RAG engine
- Emotional Intelligence: Sentiment analysis, empathy engine
- Collaboration: Multi-session state management, MCP integration
- Learning: Feedback collection, performance monitoring
- Technical: DevOps templates, code analysis, debugging assistant

Added run_full.py - fully enhanced chat interface with all modules.

run_final.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+"""
+Stack 2.9 - Qwen2 Direct Load
+"""
+import os
+os.environ['HF_HUB_DISABLE_PROGRESS_BARS'] = '1'
+
+import torch
+from pathlib import Path
+import json
+
+model_path = Path("/Users/walidsobhi/stack-2-9-final-model")
+
+print("Loading...")
+
+# Load tokenizer
+from transformers import PreTrainedTokenizerFast
+tokenizer = PreTrainedTokenizerFast(tokenizer_file=str(model_path / "tokenizer.json"))
+tokenizer.pad_token = "<|endoftext|>"
+tokenizer.eos_token = "<|endoftext|>"
+
+print("Tokenizer loaded")
+
+# Load config
+with open(model_path / "config.json") as f:
+    config_dict = json.load(f)
+
+print(f"Model type: {config_dict.get('model_type')}")
+
+# Load weights first
+print("Loading weights...")
+from safetensors.torch import load_file
+state_dict = load_file(str(model_path / "model.safetensors"))
+
+# Create model the proper way for Qwen2
+from transformers import Qwen2ForCausalLM, Qwen2Config
+
+# Create config object
+config = Qwen2Config()
+for k, v in config_dict.items():
+    setattr(config, k, v)
+
+# Initialize model with config then load weights
+model = Qwen2ForCausalLM(config)
+model.load_state_dict(state_dict, strict=False)
+model = model.to(torch.float16)
+
+if torch.cuda.is_available():
+    model.to("cuda")
+
+print("Model ready!\n")
+
+# Chat
+print("Stack 2.9 Ready!")
+print("=" * 40)
+
+while True:
+    try:
+        user_input = input("\nYou: ").strip()
+        if user_input.lower() in ['quit', 'exit', 'q']:
+            break
+
+        prompt = f"You are Stack 2.9.\n\nUser: {user_input}\nAssistant:"
+        inputs = tokenizer(prompt, return_tensors='pt')
+        if torch.cuda.is_available():
+            inputs = {k: v.cuda() for k, v in inputs.items()}
+
+        outputs = model.generate(**inputs, max_new_tokens=100, temperature=0.4, pad_token_id=tokenizer.eos_token_id)
+        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+        if "Assistant:" in response:
+            response = response.split("Assistant:")[-1].strip()
+
+        print(f"AI: {response}")
+
+    except KeyboardInterrupt:
+        break
+
+print("\nDone!")

run_full.py

@@ -0,0 +1,217 @@
+#!/usr/bin/env python3
+"""
+Stack 2.9 - Full Enhanced Chat with All Modules
+"""
+import os
+os.environ['HF_HUB_DISABLE_PROGRESS_BARS'] = '1'
+os.environ['TOKENIZERS_PARALLELISM'] = 'false'
+
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent / "src"))
+
+import torch
+import json
+import time
+
+# ============= Load Model =============
+model_path = Path("/Users/walidsobhi/stack-2-9-final-model")
+
+print("Loading tokenizer...")
+from transformers import PreTrainedTokenizerFast
+tokenizer = PreTrainedTokenizerFast(tokenizer_file=str(model_path / "tokenizer.json"))
+tokenizer.pad_token = "<|endoftext|>"
+tokenizer.eos_token = "<|endoftext|>"
+
+print("Loading config...")
+with open(model_path / "config.json") as f:
+    config_dict = json.load(f)
+
+print("Loading model...")
+from transformers import AutoModelForCausalLM
+model = AutoModelForCausalLM.from_pretrained(
+    str(model_path),
+    torch_dtype=torch.float16,
+    device_map="cpu",
+    local_files_only=True
+)
+tokenizer = AutoTokenizer.from_pretrained(str(model_path), local_files_only=True)
+tokenizer.pad_token = "<|endoftext|>"
+
+if torch.cuda.is_available():
+    model = model.to("cuda")
+
+# ============= Load Enhancement Modules =============
+print("\nLoading enhancement modules...")
+
+from enhancements.nlp import IntentDetector, EntityRecognizer
+from enhancements.knowledge_graph import RAGEngine
+from enhancements.emotional_intelligence import SentimentAnalyzer, EmpathyEngine
+from enhancements.collaboration import ConversationStateManager
+from enhancements.learning import FeedbackCollector, PerformanceMonitor
+from enhancements.technical import DevOpsTools, CodeAnalyzer, DebuggingAssistant
+
+# Initialize all modules
+intent_detector = IntentDetector()
+entity_recognizer = EntityRecognizer()
+rag_engine = RAGEngine()
+sentiment_analyzer = SentimentAnalyzer()
+empathy_engine = EmpathyEngine()
+conv_manager = ConversationStateManager()
+feedback_collector = FeedbackCollector()
+perf_monitor = PerformanceMonitor()
+devops_tools = DevOpsTools()
+code_analyzer = CodeAnalyzer()
+debugger = DebuggingAssistant()
+
+# Seed RAG
+rag_engine.add_document("intro", "Stack 2.9 is an AI coding assistant that helps with programming, debugging, and technical questions.")
+rag_engine.add_document("commands", "Commands: quit, exit, feedback, analyze:<code>, debug:<error>")
+
+print("✓ Intent Detection")
+print("✓ Entity Recognition")
+print("✓ RAG Engine")
+print("✓ Sentiment Analysis")
+print("✓ Empathy Engine")
+print("✓ Conversation Manager")
+print("✓ Feedback Collector")
+print("✓ Performance Monitor")
+print("✓ DevOps Tools")
+print("✓ Code Analyzer")
+print("✓ Debugging Assistant")
+
+print("\n" + "=" * 50)
+print("Stack 2.9 - FULLY ENHANCED")
+print("=" * 50)
+
+# ============= Chat Loop =============
+conv_manager.create_session()
+perf_monitor.increment_session_count()
+
+last_user_input = None
+last_response = None
+
+while True:
+    try:
+        user_input = input("\nYou: ").strip()
+        if not user_input:
+            continue
+
+        if user_input.lower() in ['quit', 'exit', 'q']:
+            break
+
+        # === Handle Special Commands ===
+
+        # Feedback
+        if user_input.lower() == 'feedback':
+            print("Rate last response (1-5): ", end="")
+            try:
+                rating = int(input().strip())
+                if 1 <= rating <= 5:
+                    feedback_collector.add_feedback("rating", last_user_input or "", last_response or "", rating=rating)
+                    print("✓ Thanks for feedback!")
+            except:
+                print("Invalid rating")
+            continue
+
+        # Code Analysis
+        if user_input.lower().startswith("analyze:"):
+            code = user_input[8:].strip()
+            summary = code_analyzer.get_code_summary(code)
+            print(f"\n📊 Code Analysis:")
+            print(f"   Language: {summary['language']}")
+            print(f"   Lines: {summary['complexity']['lines_of_code']}")
+            print(f"   Complexity: {summary['complexity']['cyclomatic_complexity']}")
+            print(f"   Issues: {summary['issue_count']}")
+            print(f"   Maintainability: {summary['maintainability_index']:.1f}/100")
+            if summary['suggestions']:
+                print(f"   Suggestions: {summary['suggestions']}")
+            continue
+
+        # Debug Error
+        if user_input.lower().startswith("debug:"):
+            error = user_input[6:].strip()
+            analysis = debugger.analyze_error(error)
+            print(f"\n🔧 Debug Analysis:")
+            print(f"   Error: {analysis['error_type']}")
+            print(f"   Description: {analysis['description']}")
+            print(f"   Common causes: {analysis['common_causes']}")
+            for step in analysis['debug_steps'][:4]:
+                print(f"   {step}")
+            continue
+
+        # Intent Detection
+        intent = intent_detector.detect_intent(user_input)
+
+        # Entity Recognition
+        entities = entity_recognizer.recognize_entities(user_input)
+
+        # Sentiment Analysis
+        sentiment = sentiment_analyzer.analyze_sentiment(user_input)
+
+        # RAG Context
+        rag_context = rag_engine.retrieve_as_context(user_input, 300)
+
+        # === Generate Response ===
+        start_time = time.time()
+
+        # Build prompt with enhancements
+        system = "You are Stack 2.9, an expert AI coding assistant."
+        if rag_context:
+            system += f"\nContext: {rag_context}"
+        if sentiment['sentiment'] == 'negative':
+            system += "\nBe empathetic and supportive."
+        elif sentiment['sentiment'] == 'positive':
+            system += "\nBe enthusiastic and positive."
+
+        prompt = f"{system}\n\nUser: {user_input}\nAssistant:"
+        inputs = tokenizer(prompt, return_tensors='pt')
+        if torch.cuda.is_available():
+            inputs = inputs.to("cuda")
+
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=120,
+            temperature=0.4,
+            top_p=0.9,
+            pad_token_id=tokenizer.eos_token_id
+        )
+
+        response_time = time.time() - start_time
+
+        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        if "Assistant:" in response:
+            response = response.split("Assistant:")[-1].strip()
+
+        # Apply empathy if needed
+        if sentiment['sentiment'] == 'negative':
+            response = empathy_engine.generate_empathetic_response(user_input, response)
+
+        # === Show Info ===
+        print(f"\n[Intent: {intent['intent']}]", end="")
+        if entities:
+            print(f" [Entities: {', '.join([e['type'] for e in entities[:3]])}]", end="")
+        if sentiment['sentiment'] != 'neutral':
+            print(f" [Mood: {sentiment['sentiment']}]", end="")
+        print(f" [{response_time:.2f}s]\n")
+
+        print(f"AI: {response}")
+
+        # === Track ===
+        last_user_input = user_input
+        last_response = response
+        conv_manager.add_message("user", user_input)
+        conv_manager.add_message("assistant", response)
+        perf_monitor.increment_message_count()
+        perf_monitor.record_response_time(response_time)
+
+    except KeyboardInterrupt:
+        break
+
+# Stats
+stats = perf_monitor.get_session_stats()
+print(f"\n{'='*50}")
+print(f"Session complete!")
+print(f"Messages: {stats['total_messages']}")
+print(f"Avg response time: {perf_monitor.get_average_response_time():.2f}s")
+print(f"{'='*50}")

src/enhancements/__init__.py

@@ -0,0 +1,34 @@
+"""
+Stack 2.9 Enhancement Modules
+
+This package provides comprehensive enhancements for the Stack 2.9 model:
+- NLP: Contextual embeddings, entity recognition, intent detection
+- Knowledge Graph: Graph-based knowledge with RAG support
+- Emotional Intelligence: Sentiment analysis and empathetic responses
+- Collaboration: MCP integration, conversation state management
+- Learning: Feedback collection, continuous improvement
+"""
+
+from .config import (
+    EnhancementConfig,
+    NLPConfig,
+    KnowledgeGraphConfig,
+    EmotionalIntelligenceConfig,
+    CollaborationConfig,
+    LearningConfig,
+    get_config,
+    set_config,
+)
+
+__version__ = "2.9.0"
+
+__all__ = [
+    "EnhancementConfig",
+    "NLPConfig",
+    "KnowledgeGraphConfig",
+    "EmotionalIntelligenceConfig",
+    "CollaborationConfig",
+    "LearningConfig",
+    "get_config",
+    "set_config",
+]

src/enhancements/collaboration/__init__.py

@@ -0,0 +1,13 @@
+"""
+Collaboration Module
+
+Provides collaboration features and conversational flow management.
+"""
+
+from .conversation_state import ConversationStateManager
+from .mcp_integration import MCPIntegration
+
+__all__ = [
+    "ConversationStateManager",
+    "MCPIntegration",
+]

src/enhancements/collaboration/conversation_state.py

@@ -0,0 +1,261 @@
+"""
+Conversation State Management
+
+Manages conversation state across multiple sessions.
+"""
+
+from typing import Dict, List, Optional, Any
+from datetime import datetime, timedelta
+import uuid
+import json
+from pathlib import Path
+
+
+class ConversationSession:
+    """Represents a single conversation session."""
+
+    def __init__(
+        self,
+        session_id: str,
+        user_id: Optional[str] = None,
+    ):
+        self.session_id = session_id
+        self.user_id = user_id
+        self.messages: List[Dict[str, Any]] = []
+        self.created_at = datetime.now()
+        self.last_activity = datetime.now()
+        self.metadata: Dict[str, Any] = {}
+        self.context: Dict[str, Any] = {}
+
+    def add_message(
+        self,
+        role: str,
+        content: str,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """Add a message to the session."""
+        self.messages.append({
+            "role": role,
+            "content": content,
+            "timestamp": datetime.now().isoformat(),
+            "metadata": metadata or {},
+        })
+        self.last_activity = datetime.now()
+
+    def get_messages(self, limit: Optional[int] = None) -> List[Dict[str, Any]]:
+        """Get messages, optionally limited."""
+        if limit:
+            return self.messages[-limit:]
+        return self.messages
+
+    def clear(self) -> None:
+        """Clear session messages."""
+        self.messages = []
+        self.context = {}
+
+
+class ConversationStateManager:
+    """Manages multiple conversation sessions and state."""
+
+    def __init__(
+        self,
+        max_sessions: int = 10,
+        session_timeout_minutes: int = 60,
+    ):
+        """
+        Initialize the conversation state manager.
+
+        Args:
+            max_sessions: Maximum number of concurrent sessions
+            session_timeout_minutes: Session timeout in minutes
+        """
+        self.max_sessions = max_sessions
+        self.session_timeout = timedelta(minutes=session_timeout_minutes)
+        self.sessions: Dict[str, ConversationSession] = {}
+        self.active_session_id: Optional[str] = None
+
+    def create_session(
+        self,
+        user_id: Optional[str] = None,
+        session_id: Optional[str] = None,
+    ) -> str:
+        """
+        Create a new session.
+
+        Args:
+            user_id: Optional user ID
+            session_id: Optional session ID
+
+        Returns:
+            Session ID
+        """
+        # Clean up old sessions if at max
+        if len(self.sessions) >= self.max_sessions:
+            self._cleanup_old_sessions()
+
+        session_id = session_id or str(uuid.uuid4())
+        session = ConversationSession(session_id, user_id)
+        self.sessions[session_id] = session
+        self.active_session_id = session_id
+
+        return session_id
+
+    def get_session(self, session_id: str) -> Optional[ConversationSession]:
+        """Get a session by ID."""
+        session = self.sessions.get(session_id)
+        if session:
+            # Check timeout
+            if datetime.now() - session.last_activity > self.session_timeout:
+                self.delete_session(session_id)
+                return None
+        return session
+
+    def get_active_session(self) -> Optional[ConversationSession]:
+        """Get the active session."""
+        if self.active_session_id:
+            return self.get_session(self.active_session_id)
+        return None
+
+    def set_active_session(self, session_id: str) -> bool:
+        """Set the active session."""
+        if session_id in self.sessions:
+            self.active_session_id = session_id
+            return True
+        return False
+
+    def delete_session(self, session_id: str) -> bool:
+        """Delete a session."""
+        if session_id in self.sessions:
+            del self.sessions[session_id]
+            if self.active_session_id == session_id:
+                self.active_session_id = None
+            return True
+        return False
+
+    def add_message(
+        self,
+        role: str,
+        content: str,
+        session_id: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> bool:
+        """Add a message to a session."""
+        session = self.get_session(session_id or self.active_session_id or "")
+        if not session:
+            session_id = self.create_session()
+            session = self.sessions[session_id]
+
+        session.add_message(role, content, metadata)
+        return True
+
+    def get_conversation_history(
+        self,
+        session_id: Optional[str] = None,
+        limit: Optional[int] = None,
+    ) -> List[Dict[str, Any]]:
+        """Get conversation history."""
+        session = self.get_session(session_id or self.active_session_id or "")
+        if not session:
+            return []
+        return session.get_messages(limit)
+
+    def update_context(
+        self,
+        key: str,
+        value: Any,
+        session_id: Optional[str] = None,
+    ) -> bool:
+        """Update session context."""
+        session = self.get_session(session_id or self.active_session_id or "")
+        if not session:
+            return False
+        session.context[key] = value
+        return True
+
+    def get_context(
+        self,
+        key: Optional[str] = None,
+        session_id: Optional[str] = None,
+    ) -> Any:
+        """Get session context."""
+        session = self.get_session(session_id or self.active_session_id or "")
+        if not session:
+            return None
+        if key:
+            return session.context.get(key)
+        return session.context
+
+    def _cleanup_old_sessions(self) -> None:
+        """Clean up old/timeout sessions."""
+        now = datetime.now()
+        to_delete = []
+
+        for session_id, session in self.sessions.items():
+            if now - session.last_activity > self.session_timeout:
+                to_delete.append(session_id)
+
+        # Also delete oldest if still at max
+        if len(self.sessions) - len(to_delete) >= self.max_sessions:
+            oldest = min(
+                self.sessions.values(),
+                key=lambda s: s.last_activity
+            )
+            to_delete.append(oldest.session_id)
+
+        for session_id in to_delete:
+            self.delete_session(session_id)
+
+    def get_session_info(self, session_id: str) -> Optional[Dict[str, Any]]:
+        """Get session information."""
+        session = self.get_session(session_id)
+        if not session:
+            return None
+
+        return {
+            "session_id": session.session_id,
+            "user_id": session.user_id,
+            "message_count": len(session.messages),
+            "created_at": session.created_at.isoformat(),
+            "last_activity": session.last_activity.isoformat(),
+            "metadata": session.metadata,
+        }
+
+    def get_all_sessions(self) -> List[str]:
+        """Get all active session IDs."""
+        self._cleanup_old_sessions()
+        return list(self.sessions.keys())
+
+    def save_sessions(self, filepath: str) -> None:
+        """Save sessions to file."""
+        data = {
+            session_id: {
+                "session_id": session.session_id,
+                "user_id": session.user_id,
+                "messages": session.messages,
+                "created_at": session.created_at.isoformat(),
+                "last_activity": session.last_activity.isoformat(),
+                "metadata": session.metadata,
+                "context": session.context,
+            }
+            for session_id, session in self.sessions.items()
+        }
+        Path(filepath).write_text(json.dumps(data, indent=2))
+
+    def load_sessions(self, filepath: str) -> None:
+        """Load sessions from file."""
+        data = json.loads(Path(filepath).read_text())
+
+        for session_id, session_data in data.items():
+            session = ConversationSession(
+                session_data["session_id"],
+                session_data.get("user_id"),
+            )
+            session.messages = session_data.get("messages", [])
+            session.created_at = datetime.fromisoformat(session_data["created_at"])
+            session.last_activity = datetime.fromisoformat(session_data["last_activity"])
+            session.metadata = session_data.get("metadata", {})
+            session.context = session_data.get("context", {})
+            self.sessions[session_id] = session
+
+    def __repr__(self) -> str:
+        return f"ConversationStateManager(sessions={len(self.sessions)}, max={self.max_sessions})"

src/enhancements/collaboration/mcp_integration.py

@@ -0,0 +1,241 @@
+"""
+MCP (Model Context Protocol) Integration
+
+Provides MCP client integration for tool calling and external services.
+"""
+
+from typing import Dict, List, Optional, Any, Callable
+import asyncio
+import json
+from datetime import datetime
+
+
+class MCPTool:
+    """Represents an MCP tool."""
+
+    def __init__(
+        self,
+        name: str,
+        description: str,
+        parameters: Dict[str, Any],
+        handler: Optional[Callable] = None,
+    ):
+        self.name = name
+        self.description = description
+        self.parameters = parameters
+        self.handler = handler
+
+    def __repr__(self) -> str:
+        return f"MCPTool(name='{self.name}')"
+
+
+class MCPIntegration:
+    """Integrates with MCP for tool calling and external services."""
+
+    def __init__(
+        self,
+        server_url: Optional[str] = None,
+        auto_register: bool = True,
+    ):
+        """
+        Initialize MCP integration.
+
+        Args:
+            server_url: MCP server URL (optional)
+            auto_register: Auto-register built-in tools
+        """
+        self.server_url = server_url
+        self.tools: Dict[str, MCPTool] = {}
+        self.connected = False
+        self._connection = None
+
+        if auto_register:
+            self._register_builtin_tools()
+
+    def _register_builtin_tools(self) -> None:
+        """Register built-in tools."""
+        # File operations
+        self.register_tool(MCPTool(
+            name="read_file",
+            description="Read contents of a file",
+            parameters={
+                "path": {"type": "string", "description": "File path to read"},
+            },
+        ))
+
+        self.register_tool(MCPTool(
+            name="write_file",
+            description="Write content to a file",
+            parameters={
+                "path": {"type": "string", "description": "File path to write"},
+                "content": {"type": "string", "description": "Content to write"},
+            },
+        ))
+
+        # Web search
+        self.register_tool(MCPTool(
+            name="web_search",
+            description="Search the web for information",
+            parameters={
+                "query": {"type": "string", "description": "Search query"},
+                "max_results": {"type": "integer", "description": "Max results", "default": 5},
+            },
+        ))
+
+        # Code execution
+        self.register_tool(MCPTool(
+            name="execute_code",
+            description="Execute code in a sandboxed environment",
+            parameters={
+                "code": {"type": "string", "description": "Code to execute"},
+                "language": {"type": "string", "description": "Programming language"},
+            },
+        ))
+
+        # Git operations
+        self.register_tool(MCPTool(
+            name="git_operation",
+            description="Execute git commands",
+            parameters={
+                "command": {"type": "string", "description": "Git command"},
+                "args": {"type": "array", "description": "Command arguments"},
+            },
+        ))
+
+        # Shell commands
+        self.register_tool(MCPTool(
+            name="run_command",
+            description="Run a shell command",
+            parameters={
+                "command": {"type": "string", "description": "Command to run"},
+                "timeout": {"type": "integer", "description": "Timeout in seconds", "default": 30},
+            },
+        ))
+
+    def register_tool(self, tool: MCPTool) -> None:
+        """Register a tool."""
+        self.tools[tool.name] = tool
+
+    def unregister_tool(self, name: str) -> bool:
+        """Unregister a tool."""
+        if name in self.tools:
+            del self.tools[name]
+            return True
+        return False
+
+    def get_tool(self, name: str) -> Optional[MCPTool]:
+        """Get a tool by name."""
+        return self.tools.get(name)
+
+    def list_tools(self) -> List[Dict[str, Any]]:
+        """List all registered tools."""
+        return [
+            {
+                "name": tool.name,
+                "description": tool.description,
+                "parameters": tool.parameters,
+            }
+            for tool in self.tools.values()
+        ]
+
+    async def call_tool(
+        self,
+        name: str,
+        parameters: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        """
+        Call a tool with parameters.
+
+        Args:
+            name: Tool name
+            parameters: Tool parameters
+
+        Returns:
+            Tool result
+        """
+        tool = self.get_tool(name)
+        if not tool:
+            return {
+                "success": False,
+                "error": f"Tool '{name}' not found",
+            }
+
+        try:
+            # Check if tool has a handler
+            if tool.handler:
+                if asyncio.iscoroutinefunction(tool.handler):
+                    result = await tool.handler(**parameters)
+                else:
+                    result = tool.handler(**parameters)
+                return {
+                    "success": True,
+                    "result": result,
+                }
+            else:
+                # No handler - return placeholder
+                return {
+                    "success": True,
+                    "result": f"Tool '{name}' would be called with: {parameters}",
+                    "simulated": True,
+                }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+            }
+
+    def call_tool_sync(
+        self,
+        name: str,
+        parameters: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        """Synchronous version of call_tool."""
+        tool = self.get_tool(name)
+        if not tool:
+            return {
+                "success": False,
+                "error": f"Tool '{name}' not found",
+            }
+
+        try:
+            if tool.handler:
+                result = tool.handler(**parameters)
+                return {
+                    "success": True,
+                    "result": result,
+                }
+            else:
+                return {
+                    "success": True,
+                    "result": f"Tool '{name}' would be called with: {parameters}",
+                    "simulated": True,
+                }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+            }
+
+    async def connect(self, server_url: str) -> bool:
+        """Connect to MCP server."""
+        self.server_url = server_url
+        # In a real implementation, this would establish a connection
+        self.connected = True
+        return True
+
+    async def disconnect(self) -> None:
+        """Disconnect from MCP server."""
+        self.connected = False
+        self._connection = None
+
+    def get_capabilities(self) -> Dict[str, Any]:
+        """Get MCP capabilities."""
+        return {
+            "tools": len(self.tools),
+            "connected": self.connected,
+            "server_url": self.server_url,
+            "supports_async": True,
+        }
+
+    def __repr__(self) -> str:
+        return f"MCPIntegration(tools={len(self.tools)}, connected={self.connected})"

src/enhancements/config.py

@@ -0,0 +1,118 @@
+"""
+Stack 2.9 Enhancement Configuration
+Central configuration for all enhancement features.
+"""
+
+from dataclasses import dataclass, field
+from typing import Optional
+import os
+
+
+@dataclass
+class NLPConfig:
+    """Configuration for NLP enhancements."""
+    use_bert_embeddings: bool = True
+    bert_model: str = "bert-base-uncased"
+    use_entity_recognition: bool = True
+    use_intent_detection: bool = True
+    max_context_length: int = 512
+    embedding_cache_size: int = 1000
+
+
+@dataclass
+class KnowledgeGraphConfig:
+    """Configuration for knowledge graph."""
+    enabled: bool = True
+    backend: str = "networkx"  # or "neo4j"
+    max_nodes: int = 10000
+    max_edges: int = 50000
+    similarity_threshold: float = 0.7
+    rag_enabled: bool = True
+    rag_top_k: int = 5
+
+
+@dataclass
+class EmotionalIntelligenceConfig:
+    """Configuration for emotional intelligence."""
+    enabled: bool = True
+    sentiment_model: str = "distilbert-base-uncased-finetuned-sst-2-english"
+    detect_emotions: bool = True
+    empathetic_responses: bool = True
+    emotion_sensitivity: float = 0.5
+
+
+@dataclass
+class CollaborationConfig:
+    """Configuration for collaboration features."""
+    mcp_enabled: bool = True
+    conversation_state_enabled: bool = True
+    max_sessions: int = 10
+    session_timeout_minutes: int = 60
+
+
+@dataclass
+class LearningConfig:
+    """Configuration for learning and adaptation."""
+    enabled: bool = True
+    feedback_storage_path: str = "data/feedback"
+    auto_finetune: bool = False
+    finetune_every_n_feedback: int = 100
+    performance_monitoring: bool = True
+
+
+@dataclass
+class EnhancementConfig:
+    """Main configuration for all enhancements."""
+    nlp: NLPConfig = field(default_factory=NLPConfig)
+    knowledge_graph: KnowledgeGraphConfig = field(default_factory=KnowledgeGraphConfig)
+    emotional_intelligence: EmotionalIntelligenceConfig = field(default_factory=EmotionalIntelligenceConfig)
+    collaboration: CollaborationConfig = field(default_factory=CollaborationConfig)
+    learning: LearningConfig = field(default_factory=LearningConfig)
+
+    # Global enable/disable
+    all_enabled: bool = True
+
+    @classmethod
+    def from_env(cls) -> "EnhancementConfig":
+        """Create config from environment variables."""
+        config = cls()
+
+        # NLP settings
+        if os.getenv("NLP_USE_BERT"):
+            config.nlp.use_bert_embeddings = os.getenv("NLP_USE_BERT").lower() == "true"
+        if os.getenv("NLP_BERT_MODEL"):
+            config.nlp.bert_model = os.getenv("NLP_BERT_MODEL")
+
+        # Knowledge graph settings
+        if os.getenv("KG_ENABLED"):
+            config.knowledge_graph.enabled = os.getenv("KG_ENABLED").lower() == "true"
+        if os.getenv("KG_RAG_ENABLED"):
+            config.knowledge_graph.rag_enabled = os.getenv("KG_RAG_ENABLED").lower() == "true"
+
+        # Emotional intelligence settings
+        if os.getenv("EI_ENABLED"):
+            config.emotional_intelligence.enabled = os.getenv("EI_ENABLED").lower() == "true"
+
+        # Learning settings
+        if os.getenv("LEARNING_ENABLED"):
+            config.learning.enabled = os.getenv("LEARNING_ENABLED").lower() == "true"
+
+        return config
+
+
+# Global config instance
+_default_config: Optional[EnhancementConfig] = None
+
+
+def get_config() -> EnhancementConfig:
+    """Get the global enhancement config instance."""
+    global _default_config
+    if _default_config is None:
+        _default_config = EnhancementConfig.from_env()
+    return _default_config
+
+
+def set_config(config: EnhancementConfig) -> None:
+    """Set the global enhancement config instance."""
+    global _default_config
+    _default_config = config

src/enhancements/emotional_intelligence/__init__.py

@@ -0,0 +1,13 @@
+"""
+Emotional Intelligence Module
+
+Provides sentiment analysis and empathetic response generation.
+"""
+
+from .sentiment import SentimentAnalyzer
+from .empathy import EmpathyEngine
+
+__all__ = [
+    "SentimentAnalyzer",
+    "EmpathyEngine",
+]

src/enhancements/emotional_intelligence/empathy.py

@@ -0,0 +1,222 @@
+"""
+Empathy Engine Module
+
+Provides empathetic response generation based on detected emotions.
+"""
+
+from typing import Dict, List, Optional, Any
+from .sentiment import SentimentAnalyzer
+
+
+class EmpathyEngine:
+    """Generate empathetic and contextually appropriate responses."""
+
+    # Response templates for different emotional states
+    EMPATHETIC_RESPONSES = {
+        "frustrated": [
+            "I understand this is frustrating. Let me help you work through this.",
+            "I can see you're frustrated. Let's take this step by step together.",
+            "Don't worry - we'll get this sorted out. I'm here to help.",
+        ],
+        "sad": [
+            "I'm sorry you're going through this. I'm here to help in any way I can.",
+            "That sounds difficult. Let me see what I can do to help.",
+            "I appreciate you sharing this with me. How can I help make things better?",
+        ],
+        "angry": [
+            "I understand you're frustrated. Let me help resolve this for you.",
+            "I hear you. Let's work together to find a solution.",
+            "I'm sorry you're having this experience. Let me see what I can do.",
+        ],
+        "worried": [
+            "I understand your concern. Let me help put your mind at ease.",
+            "Don't worry - I'm here to help. Let's figure this out together.",
+            "I can see you're worried. Let me provide some clarity.",
+        ],
+        "confused": [
+            "I understand this can be confusing. Let me explain in a clearer way.",
+            "That's a great question. Let me break this down for you.",
+            "No worries - I'll help you understand this better.",
+        ],
+        "excited": [
+            "That's great to hear! I'm excited to help you with this.",
+            "Awesome! Let me help you make the most of this.",
+            "I love your enthusiasm! Let's dive in and make something great.",
+        ],
+        "neutral": [
+            "I'm here to help. What would you like to work on?",
+            "How can I assist you today?",
+            "What would you like to do next?",
+        ],
+    }
+
+    TONE_MODIFIERS = {
+        "empathetic": {
+            "prefix": "I understand. ",
+            "soften_errors": True,
+            "add_reassurance": True,
+        },
+        "enthusiastic": {
+            "prefix": "Great question! ",
+            "add_excitement": True,
+            "use_strong_positives": True,
+        },
+        "supportive": {
+            "prefix": "No problem at all. ",
+            "reassure_user": True,
+            "offer_encouragement": True,
+        },
+        "helpful": {
+            "prefix": "Happy to help! ",
+            "be_direct": True,
+            "include_steps": True,
+        },
+        "neutral": {
+            "prefix": "",
+            "be_concise": True,
+        },
+    }
+
+    def __init__(self):
+        """Initialize the empathy engine."""
+        self.sentiment_analyzer = SentimentAnalyzer()
+
+    def generate_empathetic_response(
+        self,
+        user_message: str,
+        base_response: str,
+    ) -> str:
+        """
+        Generate an empathetic version of the response.
+
+        Args:
+            user_message: The user's original message
+            base_response: The generated response
+
+        Returns:
+            Empathetic response
+        """
+        # Analyze user sentiment
+        analysis = self.sentiment_analyzer.analyze_sentiment(user_message)
+
+        # Determine appropriate tone
+        tone = self.sentiment_analyzer.get_tone_adjustment(user_message)
+
+        # Get empathetic template
+        emotional_state = self._get_dominant_emotion(user_message)
+        templates = self.EMPATHETIC_RESPONSES.get(emotional_state, self.EMPATHETIC_RESPONSES["neutral"])
+
+        # Apply tone modifiers
+        modifiers = self.TONE_MODIFIERS.get(tone, self.TONE_MODIFIERS["neutral"])
+
+        # Build response
+        response = self._build_response(
+            base_response,
+            modifiers,
+            templates,
+            analysis,
+        )
+
+        return response
+
+    def _get_dominant_emotion(self, text: str) -> str:
+        """Get the dominant emotional state."""
+        if self.sentiment_analyzer.is_frustrated(text):
+            return "frustrated"
+        elif self.sentiment_analyzer.is_asking_for_help(text):
+            return "confused"
+
+        emotions = self.sentiment_analyzer.detect_emotions(text)
+        if emotions:
+            return emotions[0]["emotion"]
+
+        return "neutral"
+
+    def _build_response(
+        self,
+        base_response: str,
+        modifiers: Dict[str, bool],
+        templates: List[str],
+        analysis: Dict[str, Any],
+    ) -> str:
+        """Build the modified response."""
+        # Start with prefix if available
+        prefix = modifiers.get("prefix", "")
+        response = prefix + base_response
+
+        # Add reassurance for negative emotions
+        if modifiers.get("add_reassurance") and analysis["sentiment"] == "negative":
+            # Add a supportive note
+            if not response.endswith((". ", "!", "?")):
+                response += "."
+            response += " I'm here to help you work through this."
+
+        return response
+
+    def get_response_tone(
+        self,
+        user_message: str,
+    ) -> Dict[str, Any]:
+        """
+        Get recommended response tone.
+
+        Args:
+            user_message: User's message
+
+        Returns:
+            Dictionary with tone recommendations
+        """
+        analysis = self.sentiment_analyzer.analyze_sentiment(user_message)
+        tone = self.sentiment_analyzer.get_tone_adjustment(user_message)
+        is_frustrated = self.sentiment_analyzer.is_frustrated(user_message)
+
+        return {
+            "recommended_tone": tone,
+            "user_sentiment": analysis["sentiment"],
+            "user_emotions": analysis["emotions"],
+            "needs_empathy": analysis["sentiment"] == "negative" or is_frustrated,
+            "modifiers": self.TONE_MODIFIERS.get(tone, {}),
+        }
+
+    def adjust_response_length(
+        self,
+        user_message: str,
+        base_response: str,
+    ) -> str:
+        """
+        Adjust response length based on user state.
+
+        Args:
+            user_message: User's message
+            base_response: Base response
+
+        Returns:
+            Adjusted response
+        """
+        # If user is frustrated or confused, be more concise
+        if self.sentiment_analyzer.is_frustrated(user_message):
+            # Return first paragraph/section only
+            paragraphs = base_response.split("\n\n")
+            if paragraphs:
+                return paragraphs[0]
+        elif self.sentiment_analyzer.is_asking_for_help(user_message):
+            # Keep it comprehensive but clear
+            return base_response
+
+        return base_response
+
+    def get_supportive_phrase(self, emotion: str) -> str:
+        """Get a supportive phrase for the emotion."""
+        phrases = {
+            "frustrated": "I understand this is frustrating. Let's work through it together.",
+            "sad": "I'm sorry you're experiencing this. I'm here to help.",
+            "angry": "I hear your frustration. Let me help resolve this.",
+            "worried": "I understand your concern. Let's figure this out.",
+            "confused": "That's a good question. Let me clarify.",
+            "excited": "I'm excited to help with this!",
+            "neutral": "How can I help you today?",
+        }
+        return phrases.get(emotion, phrases["neutral"])
+
+    def __repr__(self) -> str:
+        return f"EmpathyEngine(sentiment_analyzer={self.sentiment_analyzer})"

src/enhancements/emotional_intelligence/sentiment.py

@@ -0,0 +1,238 @@
+"""
+Sentiment Analysis Module
+
+Provides sentiment and emotion detection for text.
+"""
+
+from typing import Dict, List, Optional, Any
+import re
+
+
+class SentimentAnalyzer:
+    """Analyze sentiment and emotions in text."""
+
+    # Emotion keywords for rule-based fallback
+    EMOTION_KEYWORDS = {
+        "joy": ["happy", "joy", "excited", "wonderful", "great", "love", "amazing", "awesome", "fantastic"],
+        "sadness": ["sad", "unhappy", "depressed", "down", "disappointed", "unfortunate", "sorry"],
+        "anger": ["angry", "mad", "frustrated", "annoyed", "irritated", "furious", "hate"],
+        "fear": ["afraid", "scared", "worried", "anxious", "nervous", "terrified", "fear"],
+        "surprise": ["surprised", "amazing", "incredible", "unexpected", "shocked", "wow"],
+        "anticipation": ["looking forward", "hope", "expect", "excited about", "can't wait"],
+    }
+
+    def __init__(
+        self,
+        use_transformers: bool = True,
+        model_name: str = "distilbert-base-uncased-finetuned-sst-2-english",
+    ):
+        """
+        Initialize the sentiment analyzer.
+
+        Args:
+            use_transformers: Use transformer-based sentiment analysis
+            model_name: Model name for transformer-based analysis
+        """
+        self.use_transformers = use_transformers and self._check_transformers()
+        self.model_name = model_name
+        self._pipeline = None
+
+    def _check_transformers(self) -> bool:
+        """Check if transformers is available."""
+        try:
+            import transformers
+            return True
+        except ImportError:
+            return False
+
+    def _load_pipeline(self):
+        """Lazy load the sentiment pipeline."""
+        if self._pipeline is None:
+            try:
+                from transformers import pipeline
+                self._pipeline = pipeline(
+                    "sentiment-analysis",
+                    model=self.model_name,
+                )
+            except Exception as e:
+                print(f"Warning: Could not load transformer sentiment model: {e}")
+                self.use_transformers = False
+
+    def analyze_sentiment(
+        self,
+        text: str,
+        return_scores: bool = True,
+    ) -> Dict[str, Any]:
+        """
+        Analyze sentiment of text.
+
+        Args:
+            text: Input text
+            return_scores: Return confidence scores
+
+        Returns:
+            Dictionary with sentiment, score, and emotions
+        """
+        sentiment = "neutral"
+        score = 0.5
+        emotions = []
+
+        # Try transformer-based first
+        if self.use_transformers:
+            try:
+                result = self._analyze_transformers(text)
+                sentiment = result["label"]
+                score = result["score"]
+            except Exception:
+                pass
+
+        # Fall back to rule-based
+        if sentiment == "neutral":
+            result = self._analyze_rule_based(text)
+            sentiment = result["sentiment"]
+            score = result["score"]
+            emotions = result["emotions"]
+
+        # Detect emotions
+        emotions = self.detect_emotions(text)
+
+        return {
+            "sentiment": sentiment,
+            "score": score,
+            "emotions": emotions,
+        }
+
+    def _analyze_transformers(self, text: str) -> Dict[str, Any]:
+        """Use transformer for sentiment analysis."""
+        self._load_pipeline()
+
+        if self._pipeline is None:
+            return {"label": "neutral", "score": 0.5}
+
+        # Truncate long text
+        text = text[:512]
+        result = self._pipeline(text)[0]
+
+        return {
+            "label": result["label"].lower(),
+            "score": result["score"],
+        }
+
+    def _analyze_rule_based(self, text: str) -> Dict[str, Any]:
+        """Rule-based sentiment analysis."""
+        text_lower = text.lower()
+
+        positive_words = ["good", "great", "excellent", "amazing", "wonderful", "fantastic",
+                          "love", "happy", "joy", "best", "perfect", "awesome", "like"]
+        negative_words = ["bad", "terrible", "awful", "horrible", "worst", "hate", "sad",
+                          "angry", "disappointed", "frustrated", "annoying", "poor", "fail"]
+
+        pos_count = sum(1 for word in positive_words if word in text_lower)
+        neg_count = sum(1 for word in negative_words if word in text_lower)
+
+        total = pos_count + neg_count
+        if total == 0:
+            return {"sentiment": "neutral", "score": 0.5, "emotions": []}
+
+        if pos_count > neg_count:
+            score = min(0.5 + (pos_count - neg_count) * 0.1, 0.95)
+            sentiment = "positive"
+        elif neg_count > pos_count:
+            score = max(0.5 - (neg_count - pos_count) * 0.1, 0.05)
+            sentiment = "negative"
+        else:
+            sentiment = "neutral"
+            score = 0.5
+
+        return {"sentiment": sentiment, "score": score, "emotions": []}
+
+    def detect_emotions(self, text: str) -> List[Dict[str, float]]:
+        """
+        Detect emotions in text.
+
+        Args:
+            text: Input text
+
+        Returns:
+            List of emotion dictionaries with scores
+        """
+        text_lower = text.lower()
+        emotions = []
+
+        for emotion, keywords in self.EMOTION_KEYWORDS.items():
+            score = 0.0
+            for keyword in keywords:
+                if keyword in text_lower:
+                    score += 1.0
+
+            if score > 0:
+                # Normalize score
+                score = min(score / len(keywords), 1.0)
+                emotions.append({
+                    "emotion": emotion,
+                    "score": score,
+                })
+
+        # Sort by score
+        emotions.sort(key=lambda x: -x["score"])
+        return emotions[:3]
+
+    def get_emotion_intensity(self, text: str) -> float:
+        """
+        Get overall emotion intensity (0-1).
+
+        Args:
+            text: Input text
+
+        Returns:
+            Emotion intensity score
+        """
+        emotions = self.detect_emotions(text)
+        if not emotions:
+            return 0.0
+
+        return max(e["score"] for e in emotions)
+
+    def is_frustrated(self, text: str) -> bool:
+        """Check if user seems frustrated."""
+        frustration_indicators = [
+            "frustrated", "annoyed", "angry", "mad", "sick of", "tired of",
+            "this is useless", "this doesn't work", "why won't", "can't figure out",
+        ]
+        text_lower = text.lower()
+        return any(indicator in text_lower for indicator in frustration_indicators)
+
+    def is_asking_for_help(self, text: str) -> bool:
+        """Check if user is asking for help."""
+        help_indicators = [
+            "help", "how do i", "can you", "please", "i need", "need help",
+            "stuck", "confused", "don't understand", "having trouble",
+        ]
+        text_lower = text.lower()
+        return any(indicator in text_lower for indicator in help_indicators)
+
+    def get_tone_adjustment(self, text: str) -> str:
+        """
+        Get recommended tone adjustment based on sentiment.
+
+        Args:
+            text: Input text
+
+        Returns:
+            Tone adjustment recommendation
+        """
+        analysis = self.analyze_sentiment(text)
+
+        if analysis["sentiment"] == "negative":
+            return "empathetic"
+        elif analysis["sentiment"] == "positive":
+            return "enthusiastic"
+        elif self.is_frustrated(text):
+            return "supportive"
+        elif self.is_asking_for_help(text):
+            return "helpful"
+        else:
+            return "neutral"
+
+    def __repr__(self) -> str:
+        return f"SentimentAnalyzer(use_transformers={self.use_transformers}, model='{self.model_name}')"

src/enhancements/knowledge_graph/__init__.py

@@ -0,0 +1,13 @@
+"""
+Knowledge Graph Module
+
+Provides graph-based knowledge representation with RAG support.
+"""
+
+from .graph import KnowledgeGraph
+from .rag import RAGEngine
+
+__all__ = [
+    "KnowledgeGraph",
+    "RAGEngine",
+]

src/enhancements/knowledge_graph/graph.py

@@ -0,0 +1,287 @@
+"""
+Knowledge Graph Implementation
+
+Graph-based knowledge representation using networkx.
+"""
+
+from typing import List, Dict, Optional, Any, Set, Tuple
+import networkx as nx
+import numpy as np
+from datetime import datetime
+import json
+from pathlib import Path
+
+
+class KnowledgeGraph:
+    """Graph-based knowledge representation with entities and relationships."""
+
+    def __init__(
+        self,
+        max_nodes: int = 10000,
+        max_edges: int = 50000,
+    ):
+        """
+        Initialize the knowledge graph.
+
+        Args:
+            max_nodes: Maximum number of nodes
+            max_edges: Maximum number of edges
+        """
+        self.max_nodes = max_nodes
+        self.max_edges = max_edges
+        self.graph = nx.MultiDiGraph()
+        self._node_attributes: Dict[str, Dict[str, Any]] = {}
+        self._edge_attributes: Dict[Tuple[str, str], Dict[str, Any]] = {}
+
+    def add_entity(
+        self,
+        entity_id: str,
+        entity_type: str,
+        properties: Optional[Dict[str, Any]] = None,
+    ) -> bool:
+        """
+        Add an entity to the knowledge graph.
+
+        Args:
+            entity_id: Unique identifier for the entity
+            entity_type: Type of entity (e.g., 'person', 'concept', 'code')
+            properties: Additional properties
+
+        Returns:
+            True if added, False if limit reached
+        """
+        if self.graph.number_of_nodes() >= self.max_nodes:
+            return False
+
+        if entity_id not in self.graph:
+            self.graph.add_node(entity_id, type=entity_type)
+
+        self._node_attributes[entity_id] = {
+            "type": entity_type,
+            "created_at": datetime.now().isoformat(),
+            "properties": properties or {},
+        }
+
+        return True
+
+    def add_relationship(
+        self,
+        source_id: str,
+        target_id: str,
+        relationship_type: str,
+        properties: Optional[Dict[str, Any]] = None,
+    ) -> bool:
+        """
+        Add a relationship between entities.
+
+        Args:
+            source_id: Source entity ID
+            target_id: Target entity ID
+            relationship_type: Type of relationship
+            properties: Additional properties
+
+        Returns:
+            True if added, False if limit reached or entities don't exist
+        """
+        if self.graph.number_of_edges() >= self.max_edges:
+            return False
+
+        # Ensure entities exist
+        if source_id not in self.graph:
+            self.add_entity(source_id, "unknown")
+        if target_id not in self.graph:
+            self.add_entity(target_id, "unknown")
+
+        self.graph.add_edge(source_id, target_id, type=relationship_type)
+
+        edge_key = (source_id, target_id)
+        self._edge_attributes[edge_key] = {
+            "type": relationship_type,
+            "created_at": datetime.now().isoformat(),
+            "properties": properties or {},
+        }
+
+        return True
+
+    def get_entity(self, entity_id: str) -> Optional[Dict[str, Any]]:
+        """Get entity information."""
+        if entity_id not in self.graph:
+            return None
+
+        return {
+            "id": entity_id,
+            **self._node_attributes.get(entity_id, {}),
+        }
+
+    def get_relationships(
+        self,
+        entity_id: str,
+        relationship_type: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        """Get relationships for an entity."""
+        if entity_id not in self.graph:
+            return []
+
+        relationships = []
+        for source, target, data in self.graph.edges(data=True):
+            if source == entity_id or target == entity_id:
+                rel_type = data.get("type", "unknown")
+                if relationship_type and rel_type != relationship_type:
+                    continue
+
+                relationships.append({
+                    "source": source,
+                    "target": target,
+                    "type": rel_type,
+                })
+
+        return relationships
+
+    def find_similar_entities(
+        self,
+        entity_id: str,
+        max_results: int = 5,
+    ) -> List[Tuple[str, float]]:
+        """
+        Find similar entities using graph-based similarity.
+
+        Args:
+            entity_id: Entity to find similar
+            max_results: Maximum number of results
+
+        Returns:
+            List of (entity_id, similarity_score) tuples
+        """
+        if entity_id not in self.graph:
+            return []
+
+        # Use common neighbors as simple similarity
+        neighbors = set(self.graph.neighbors(entity_id))
+        scores = []
+
+        for node in self.graph.nodes():
+            if node == entity_id:
+                continue
+
+            node_neighbors = set(self.graph.neighbors(node))
+            common = len(neighbors & node_neighbors)
+
+            if common > 0:
+                # Jaccard-like similarity
+                union = len(neighbors | node_neighbors)
+                score = common / union if union > 0 else 0
+                scores.append((node, score))
+
+        scores.sort(key=lambda x: -x[1])
+        return scores[:max_results]
+
+    def search_entities(
+        self,
+        entity_type: Optional[str] = None,
+        property_filter: Optional[Dict[str, Any]] = None,
+    ) -> List[str]:
+        """
+        Search for entities.
+
+        Args:
+            entity_type: Filter by entity type
+            property_filter: Filter by properties
+
+        Returns:
+            List of matching entity IDs
+        """
+        results = []
+
+        for node in self.graph.nodes():
+            attrs = self._node_attributes.get(node, {})
+
+            # Check type filter
+            if entity_type and attrs.get("type") != entity_type:
+                continue
+
+            # Check property filter
+            if property_filter:
+                props = attrs.get("properties", {})
+                if not all(props.get(k) == v for k, v in property_filter.items()):
+                    continue
+
+            results.append(node)
+
+        return results
+
+    def get_subgraph(
+        self,
+        entity_ids: List[str],
+        depth: int = 1,
+    ) -> nx.MultiDiGraph:
+        """
+        Get a subgraph around specified entities.
+
+        Args:
+            entity_ids: Center entities
+            depth: How many hops to include
+
+        Returns:
+            Subgraph
+        """
+        nodes = set(entity_ids)
+
+        for _ in range(depth):
+            for entity in list(nodes):
+                nodes.update(self.graph.neighbors(entity))
+
+        return self.graph.subgraph(nodes).copy()
+
+    def export_json(self, filepath: str) -> None:
+        """Export graph to JSON."""
+        data = {
+            "nodes": [
+                {
+                    "id": node,
+                    **self._node_attributes.get(node, {}),
+                }
+                for node in self.graph.nodes()
+            ],
+            "edges": [
+                {
+                    "source": source,
+                    "target": target,
+                    "type": data.get("type", "unknown"),
+                }
+                for source, target, data in self.graph.edges(data=True)
+            ],
+        }
+
+        Path(filepath).write_text(json.dumps(data, indent=2))
+
+    def import_json(self, filepath: str) -> None:
+        """Import graph from JSON."""
+        data = json.loads(Path(filepath).read_text())
+
+        for node_data in data.get("nodes", []):
+            node_id = node_data.pop("id")
+            self.add_entity(node_id, node_data.get("type", "unknown"), node_data.get("properties"))
+
+        for edge_data in data.get("edges", []):
+            self.add_relationship(
+                edge_data["source"],
+                edge_data["target"],
+                edge_data.get("type", "unknown"),
+            )
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Get graph statistics."""
+        return {
+            "num_nodes": self.graph.number_of_nodes(),
+            "num_edges": self.graph.number_of_edges(),
+            "num_node_types": len(set(
+                attrs.get("type") for attrs in self._node_attributes.values()
+            )),
+            "num_edge_types": len(set(
+                data.get("type") for _, _, data in self.graph.edges(data=True)
+            )),
+        }
+
+    def __repr__(self) -> str:
+        stats = self.get_stats()
+        return f"KnowledgeGraph(nodes={stats['num_nodes']}, edges={stats['num_edges']})"

src/enhancements/knowledge_graph/rag.py

@@ -0,0 +1,250 @@
+"""
+RAG (Retrieval-Augmented Generation) Engine
+
+Provides context retrieval for augmented generation.
+"""
+
+from typing import List, Dict, Optional, Any, Tuple
+import numpy as np
+from collections import defaultdict
+import re
+from datetime import datetime
+
+
+class Document:
+    """Represents a document for RAG."""
+
+    def __init__(
+        self,
+        doc_id: str,
+        content: str,
+        metadata: Optional[Dict[str, Any]] = None,
+    ):
+        self.id = doc_id
+        self.content = content
+        self.metadata = metadata or {}
+        self.embeddings: Optional[np.ndarray] = None
+        self.created_at = self.metadata.get("created_at", datetime.now().isoformat())
+
+    def __repr__(self) -> str:
+        return f"Document(id='{self.id}', content_length={len(self.content)})"
+
+
+class RAGEngine:
+    """Retrieval-Augmented Generation engine for context-aware responses."""
+
+    def __init__(
+        self,
+        top_k: int = 5,
+        similarity_threshold: float = 0.7,
+    ):
+        """
+        Initialize the RAG engine.
+
+        Args:
+            top_k: Number of top results to retrieve
+            similarity_threshold: Minimum similarity for retrieval
+        """
+        self.top_k = top_k
+        self.similarity_threshold = similarity_threshold
+        self.documents: Dict[str, Document] = {}
+        self.document_embeddings: Dict[str, np.ndarray] = {}
+        self._index_initialized = False
+        self._keyword_index: Dict[str, set] = defaultdict(set)
+
+    def add_document(
+        self,
+        doc_id: str,
+        content: str,
+        metadata: Optional[Dict[str, Any]] = None,
+        embedding: Optional[np.ndarray] = None,
+    ) -> None:
+        """
+        Add a document to the RAG index.
+
+        Args:
+            doc_id: Unique document ID
+            content: Document content
+            metadata: Document metadata
+            embedding: Pre-computed embedding (optional)
+        """
+        doc = Document(doc_id, content, metadata)
+        if embedding is not None:
+            doc.embeddings = embedding
+
+        self.documents[doc_id] = doc
+
+        # Update keyword index
+        keywords = self._extract_keywords(content)
+        for keyword in keywords:
+            self._keyword_index[keyword].add(doc_id)
+
+        self._index_initialized = False
+
+    def _extract_keywords(self, text: str) -> List[str]:
+        """Extract keywords from text."""
+        # Simple keyword extraction
+        words = re.findall(r'\b\w+\b', text.lower())
+        # Filter short words and common words
+        stopwords = {'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been',
+                     'being', 'have', 'has', 'had', 'do', 'does', 'did', 'will',
+                     'would', 'could', 'should', 'may', 'might', 'must', 'shall',
+                     'can', 'need', 'dare', 'ought', 'used', 'to', 'of', 'in',
+                     'for', 'on', 'with', 'at', 'by', 'from', 'as', 'into',
+                     'through', 'during', 'before', 'after', 'above', 'below',
+                     'between', 'under', 'again', 'further', 'then', 'once'}
+        return [w for w in words if len(w) > 2 and w not in stopwords]
+
+    def _build_index(self) -> None:
+        """Build similarity index."""
+        if not self.documents:
+            return
+
+        # Initialize embeddings for documents without them
+        for doc_id, doc in self.documents.items():
+            if doc.embeddings is None:
+                # Create simple embedding based on word frequencies
+                doc.embeddings = self._create_simple_embedding(doc.content)
+
+        self._index_initialized = True
+
+    def _create_simple_embedding(self, text: str) -> np.ndarray:
+        """Create a simple bag-of-words embedding."""
+        keywords = self._extract_keywords(text)
+        embedding = np.zeros(len(self._keyword_index))
+
+        for i, keyword in enumerate(self._keyword_index.keys()):
+            if keyword in keywords:
+                embedding[i] = keywords.count(keyword)
+
+        # Normalize
+        norm = np.linalg.norm(embedding)
+        if norm > 0:
+            embedding /= norm
+
+        return embedding
+
+    def retrieve(
+        self,
+        query: str,
+        top_k: Optional[int] = None,
+        use_keyword_index: bool = True,
+    ) -> List[Tuple[Document, float]]:
+        """
+        Retrieve relevant documents for a query.
+
+        Args:
+            query: Query text
+            top_k: Override default top_k
+            use_keyword_index: Use keyword pre-filtering
+
+        Returns:
+            List of (document, similarity_score) tuples
+        """
+        if not self.documents:
+            return []
+
+        self._build_index()
+
+        top_k = top_k or self.top_k
+
+        # Create query embedding
+        query_embedding = self._create_simple_embedding(query)
+
+        # Get candidate document IDs
+        candidate_ids = set(self.documents.keys())
+        if use_keyword_index:
+            query_keywords = self._extract_keywords(query)
+            keyword_candidates = set()
+            for keyword in query_keywords:
+                keyword_candidates.update(self._keyword_index.get(keyword, set()))
+            if keyword_candidates:
+                candidate_ids &= keyword_candidates
+
+        # Calculate similarities
+        scores = []
+        for doc_id in candidate_ids:
+            doc = self.documents[doc_id]
+            if doc.embeddings is not None:
+                similarity = np.dot(query_embedding, doc.embeddings)
+                if similarity >= self.similarity_threshold:
+                    scores.append((doc, similarity))
+
+        # Sort by similarity and return top_k
+        scores.sort(key=lambda x: -x[1])
+        return scores[:top_k]
+
+    def retrieve_as_context(
+        self,
+        query: str,
+        max_context_length: int = 1000,
+    ) -> str:
+        """
+        Retrieve documents and format as context string.
+
+        Args:
+            query: Query text
+            max_context_length: Maximum length of context
+
+        Returns:
+            Formatted context string
+        """
+        results = self.retrieve(query)
+
+        if not results:
+            return ""
+
+        context_parts = []
+        current_length = 0
+
+        for doc, score in results:
+            if current_length >= max_context_length:
+                break
+
+            # Add document with relevance score
+            context = f"[Relevance: {score:.2f}]\n{doc.content}\n"
+            if current_length + len(context) <= max_context_length:
+                context_parts.append(context)
+                current_length += len(context)
+
+        return "\n".join(context_parts)
+
+    def search(self, query: str) -> List[Document]:
+        """Simple text search in documents."""
+        results = []
+        query_lower = query.lower()
+
+        for doc in self.documents.values():
+            if query_lower in doc.content.lower():
+                results.append(doc)
+
+        return results
+
+    def get_document(self, doc_id: str) -> Optional[Document]:
+        """Get a document by ID."""
+        return self.documents.get(doc_id)
+
+    def delete_document(self, doc_id: str) -> bool:
+        """Delete a document."""
+        if doc_id in self.documents:
+            # Update keyword index
+            keywords = self._extract_keywords(self.documents[doc_id].content)
+            for keyword in keywords:
+                self._keyword_index[keyword].discard(doc_id)
+
+            del self.documents[doc_id]
+            self._index_initialized = False
+            return True
+        return False
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Get RAG engine statistics."""
+        return {
+            "num_documents": len(self.documents),
+            "num_keywords": len(self._keyword_index),
+            "index_initialized": self._index_initialized,
+        }
+
+    def __repr__(self) -> str:
+        stats = self.get_stats()
+        return f"RAGEngine(docs={stats['num_documents']}, keywords={stats['num_keywords']})"

src/enhancements/learning/__init__.py

@@ -0,0 +1,13 @@
+"""
+Learning and Adaptation Module
+
+Provides feedback collection and continuous learning capabilities.
+"""
+
+from .feedback import FeedbackCollector
+from .performance import PerformanceMonitor
+
+__all__ = [
+    "FeedbackCollector",
+    "PerformanceMonitor",
+]

src/enhancements/learning/feedback.py

@@ -0,0 +1,307 @@
+"""
+Feedback Collection System
+
+Collects user feedback for continuous improvement.
+"""
+
+from typing import Dict, List, Optional, Any
+from datetime import datetime
+import json
+from pathlib import Path
+import uuid
+
+
+class FeedbackEntry:
+    """Represents a single feedback entry."""
+
+    def __init__(
+        self,
+        feedback_type: str,
+        user_id: Optional[str],
+        message: str,
+        response: str,
+        rating: Optional[int] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ):
+        self.id = str(uuid.uuid4())
+        self.feedback_type = feedback_type  # "thumbs_up", "thumbs_down", "correction", "suggestion"
+        self.user_id = user_id
+        self.message = message
+        self.response = response
+        self.rating = rating  # 1-5 scale
+        self.metadata = metadata or {}
+        self.created_at = datetime.now()
+        self.processed = False
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "id": self.id,
+            "feedback_type": self.feedback_type,
+            "user_id": self.user_id,
+            "message": self.message,
+            "response": self.response,
+            "rating": self.rating,
+            "metadata": self.metadata,
+            "created_at": self.created_at.isoformat(),
+            "processed": self.processed,
+        }
+
+
+class FeedbackCollector:
+    """Collects and manages user feedback."""
+
+    def __init__(
+        self,
+        storage_path: str = "data/feedback",
+        auto_save: bool = True,
+    ):
+        """
+        Initialize the feedback collector.
+
+        Args:
+            storage_path: Path to store feedback data
+            auto_save: Automatically save feedback to disk
+        """
+        self.storage_path = Path(storage_path)
+        self.auto_save = auto_save
+        self.feedback_list: List[FeedbackEntry] = []
+
+        # Create storage directory if it doesn't exist
+        if auto_save:
+            self.storage_path.mkdir(parents=True, exist_ok=True)
+
+    def add_feedback(
+        self,
+        feedback_type: str,
+        message: str,
+        response: str,
+        user_id: Optional[str] = None,
+        rating: Optional[int] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> str:
+        """
+        Add a feedback entry.
+
+        Args:
+            feedback_type: Type of feedback
+            message: User's message
+            response: AI's response
+            user_id: Optional user ID
+            rating: Optional rating (1-5)
+            metadata: Additional metadata
+
+        Returns:
+            Feedback ID
+        """
+        entry = FeedbackEntry(
+            feedback_type=feedback_type,
+            user_id=user_id,
+            message=message,
+            response=response,
+            rating=rating,
+            metadata=metadata,
+        )
+
+        self.feedback_list.append(entry)
+
+        if self.auto_save:
+            self._save_feedback(entry)
+
+        return entry.id
+
+    def add_thumbs_up(
+        self,
+        message: str,
+        response: str,
+        user_id: Optional[str] = None,
+    ) -> str:
+        """Add positive feedback."""
+        return self.add_feedback(
+            feedback_type="thumbs_up",
+            message=message,
+            response=response,
+            user_id=user_id,
+            rating=5,
+        )
+
+    def add_thumbs_down(
+        self,
+        message: str,
+        response: str,
+        user_id: Optional[str] = None,
+        reason: Optional[str] = None,
+    ) -> str:
+        """Add negative feedback."""
+        return self.add_feedback(
+            feedback_type="thumbs_down",
+            message=message,
+            response=response,
+            user_id=user_id,
+            rating=1,
+            metadata={"reason": reason} if reason else {},
+        )
+
+    def add_correction(
+        self,
+        message: str,
+        original_response: str,
+        corrected_response: str,
+        user_id: Optional[str] = None,
+    ) -> str:
+        """Add a correction."""
+        return self.add_feedback(
+            feedback_type="correction",
+            message=message,
+            response=original_response,
+            user_id=user_id,
+            metadata={"corrected_response": corrected_response},
+        )
+
+    def add_suggestion(
+        self,
+        message: str,
+        response: str,
+        suggestion: str,
+        user_id: Optional[str] = None,
+    ) -> str:
+        """Add a suggestion."""
+        return self.add_feedback(
+            feedback_type="suggestion",
+            message=message,
+            response=response,
+            user_id=user_id,
+            metadata={"suggestion": suggestion},
+        )
+
+    def get_feedback(
+        self,
+        feedback_id: str,
+    ) -> Optional[FeedbackEntry]:
+        """Get feedback by ID."""
+        for entry in self.feedback_list:
+            if entry.id == feedback_id:
+                return entry
+        return None
+
+    def get_all_feedback(
+        self,
+        feedback_type: Optional[str] = None,
+        unprocessed_only: bool = False,
+    ) -> List[FeedbackEntry]:
+        """Get all feedback entries."""
+        results = self.feedback_list
+
+        if feedback_type:
+            results = [f for f in results if f.feedback_type == feedback_type]
+
+        if unprocessed_only:
+            results = [f for f in results if not f.processed]
+
+        return results
+
+    def mark_processed(self, feedback_id: str) -> bool:
+        """Mark feedback as processed."""
+        entry = self.get_feedback(feedback_id)
+        if entry:
+            entry.processed = True
+            return True
+        return False
+
+    def get_statistics(self) -> Dict[str, Any]:
+        """Get feedback statistics."""
+        total = len(self.feedback_list)
+        if total == 0:
+            return {
+                "total": 0,
+                "by_type": {},
+                "average_rating": 0,
+                "processed_count": 0,
+            }
+
+        by_type: Dict[str, int] = {}
+        ratings = []
+
+        for entry in self.feedback_list:
+            by_type[entry.feedback_type] = by_type.get(entry.feedback_type, 0) + 1
+            if entry.rating is not None:
+                ratings.append(entry.rating)
+
+        avg_rating = sum(ratings) / len(ratings) if ratings else 0
+        processed = sum(1 for e in self.feedback_list if e.processed)
+
+        return {
+            "total": total,
+            "by_type": by_type,
+            "average_rating": avg_rating,
+            "processed_count": processed,
+            "unprocessed_count": total - processed,
+        }
+
+    def get_corrections_for_finetuning(self) -> List[Dict[str, Any]]:
+        """Get corrections formatted for fine-tuning."""
+        corrections = self.get_all_feedback(feedback_type="correction")
+
+        return [
+            {
+                "instruction": entry.message,
+                "output": entry.metadata.get("corrected_response", entry.response),
+            }
+            for entry in corrections
+        ]
+
+    def export_finetuning_data(
+        self,
+        filepath: str,
+    ) -> None:
+        """Export feedback as fine-tuning data."""
+        corrections = self.get_corrections_for_finetuning()
+        Path(filepath).write_text(json.dumps(corrections, indent=2))
+
+    def _save_feedback(self, entry: FeedbackEntry) -> None:
+        """Save feedback to file."""
+        filepath = self.storage_path / f"{entry.id}.json"
+        filepath.write_text(json.dumps(entry.to_dict(), indent=2))
+
+    def load_feedback(self) -> None:
+        """Load feedback from storage directory."""
+        if not self.storage_path.exists():
+            return
+
+        for filepath in self.storage_path.glob("*.json"):
+            try:
+                data = json.loads(filepath.read_text())
+                entry = FeedbackEntry(
+                    feedback_type=data["feedback_type"],
+                    user_id=data.get("user_id"),
+                    message=data["message"],
+                    response=data["response"],
+                    rating=data.get("rating"),
+                    metadata=data.get("metadata", {}),
+                )
+                entry.id = data["id"]
+                entry.processed = data.get("processed", False)
+                entry.created_at = datetime.fromisoformat(data["created_at"])
+                self.feedback_list.append(entry)
+            except Exception as e:
+                print(f"Error loading feedback from {filepath}: {e}")
+
+    def clear_old_feedback(self, days: int = 30) -> int:
+        """Clear feedback older than specified days."""
+        cutoff = datetime.now() - timedelta(days=days)
+        original_count = len(self.feedback_list)
+
+        self.feedback_list = [
+            f for f in self.feedback_list
+            if f.created_at > cutoff
+        ]
+
+        return original_count - len(self.feedback_list)
+
+    def __repr__(self) -> str:
+        stats = self.get_statistics()
+        return f"FeedbackCollector(total={stats['total']}, unprocessed={stats['unprocessed_count']})"
+
+
+# Add missing import
+from datetime import timedelta

src/enhancements/learning/performance.py

@@ -0,0 +1,262 @@
+"""
+Performance Monitoring System
+
+Monitors and tracks model performance metrics.
+"""
+
+from typing import Dict, List, Optional, Any
+from datetime import datetime, timedelta
+from collections import defaultdict
+import json
+from pathlib import Path
+
+
+class PerformanceMetric:
+    """Represents a single performance metric."""
+
+    def __init__(
+        self,
+        metric_type: str,
+        value: float,
+        unit: str = "",
+        metadata: Optional[Dict[str, Any]] = None,
+    ):
+        self.metric_type = metric_type
+        self.value = value
+        self.unit = unit
+        self.metadata = metadata or {}
+        self.timestamp = datetime.now()
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "metric_type": self.metric_type,
+            "value": self.value,
+            "unit": self.unit,
+            "metadata": self.metadata,
+            "timestamp": self.timestamp.isoformat(),
+        }
+
+
+class PerformanceMonitor:
+    """Monitors model performance over time."""
+
+    def __init__(
+        self,
+        storage_path: str = "data/performance",
+    ):
+        """
+        Initialize the performance monitor.
+
+        Args:
+            storage_path: Path to store performance data
+        """
+        self.storage_path = Path(storage_path)
+        self.storage_path.mkdir(parents=True, exist_ok=True)
+
+        self.metrics: List[PerformanceMetric] = []
+        self._session_stats: Dict[str, Any] = {
+            "total_sessions": 0,
+            "total_messages": 0,
+            "total_conversations": 0,
+        }
+
+    def record_metric(
+        self,
+        metric_type: str,
+        value: float,
+        unit: str = "",
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """Record a performance metric."""
+        metric = PerformanceMetric(metric_type, value, unit, metadata)
+        self.metrics.append(metric)
+
+    def record_response_time(self, seconds: float) -> None:
+        """Record response time."""
+        self.record_metric("response_time", seconds, "seconds")
+
+    def record_token_count(self, prompt_tokens: int, completion_tokens: int) -> None:
+        """Record token count."""
+        self.record_metric(
+            "prompt_tokens",
+            prompt_tokens,
+            "tokens",
+            {"completion_tokens": completion_tokens},
+        )
+
+    def record_successful_interaction(self) -> None:
+        """Record a successful interaction."""
+        self.record_metric("successful_interaction", 1, "count")
+
+    def record_failed_interaction(self, error_type: str) -> None:
+        """Record a failed interaction."""
+        self.record_metric(
+            "failed_interaction",
+            1,
+            "count",
+            {"error_type": error_type},
+        )
+
+    def record_user_rating(self, rating: int) -> None:
+        """Record user rating."""
+        self.record_metric("user_rating", rating, "stars")
+
+    def get_metrics(
+        self,
+        metric_type: Optional[str] = None,
+        since: Optional[datetime] = None,
+        limit: int = 100,
+    ) -> List[PerformanceMetric]:
+        """Get recorded metrics."""
+        results = self.metrics
+
+        if metric_type:
+            results = [m for m in results if m.metric_type == metric_type]
+
+        if since:
+            results = [m for m in results if m.timestamp >= since]
+
+        return results[-limit:]
+
+    def get_average_response_time(
+        self,
+        since: Optional[datetime] = None,
+    ) -> float:
+        """Get average response time."""
+        metrics = self.get_metrics("response_time", since=since)
+        if not metrics:
+            return 0.0
+        return sum(m.value for m in metrics) / len(metrics)
+
+    def get_success_rate(
+        self,
+        since: Optional[datetime] = None,
+    ) -> float:
+        """Get interaction success rate."""
+        successful = len(self.get_metrics("successful_interaction", since=since))
+        failed = len(self.get_metrics("failed_interaction", since=since))
+
+        total = successful + failed
+        if total == 0:
+            return 0.0
+
+        return successful / total
+
+    def get_average_rating(
+        self,
+        since: Optional[datetime] = None,
+    ) -> float:
+        """Get average user rating."""
+        ratings = self.get_metrics("user_rating", since=since)
+        if not ratings:
+            return 0.0
+        return sum(m.value for m in ratings) / len(ratings)
+
+    def get_summary(
+        self,
+        since: Optional[datetime] = None,
+    ) -> Dict[str, Any]:
+        """Get performance summary."""
+        since = since or (datetime.now() - timedelta(hours=24))
+
+        return {
+            "period": "last_24_hours" if since == datetime.now() - timedelta(hours=24) else "custom",
+            "average_response_time": self.get_average_response_time(since),
+            "success_rate": self.get_success_rate(since),
+            "average_rating": self.get_average_rating(since),
+            "total_interactions": len(self.get_metrics("successful_interaction", since=since)) +
+                                 len(self.get_metrics("failed_interaction", since=since)),
+            "total_tokens": sum(
+                m.value for m in self.get_metrics("prompt_tokens", since=since)
+            ),
+        }
+
+    def increment_session_count(self) -> None:
+        """Increment session count."""
+        self._session_stats["total_sessions"] += 1
+
+    def increment_message_count(self) -> None:
+        """Increment message count."""
+        self._session_stats["total_messages"] += 1
+
+    def get_session_stats(self) -> Dict[str, Any]:
+        """Get session statistics."""
+        return self._session_stats.copy()
+
+    def export_metrics(
+        self,
+        filepath: Optional[str] = None,
+    ) -> str:
+        """Export metrics to JSON file."""
+        filepath = filepath or str(self.storage_path / f"metrics_{datetime.now().strftime('%Y%m%d')}.json")
+
+        data = {
+            "exported_at": datetime.now().isoformat(),
+            "metrics": [m.to_dict() for m in self.metrics],
+            "session_stats": self._session_stats,
+        }
+
+        Path(filepath).write_text(json.dumps(data, indent=2))
+        return filepath
+
+    def load_metrics(
+        self,
+        filepath: str,
+    ) -> None:
+        """Load metrics from JSON file."""
+        data = json.loads(Path(filepath).read_text())
+
+        for metric_data in data.get("metrics", []):
+            metric = PerformanceMetric(
+                metric_type=metric_data["metric_type"],
+                value=metric_data["value"],
+                unit=metric_data.get("unit", ""),
+                metadata=metric_data.get("metadata", {}),
+            )
+            metric.timestamp = datetime.fromisoformat(metric_data["timestamp"])
+            self.metrics.append(metric)
+
+        if "session_stats" in data:
+            self._session_stats.update(data["session_stats"])
+
+    def clear_old_metrics(self, days: int = 30) -> int:
+        """Clear metrics older than specified days."""
+        cutoff = datetime.now() - timedelta(days=days)
+        original_count = len(self.metrics)
+
+        self.metrics = [
+            m for m in self.metrics
+            if m.timestamp > cutoff
+        ]
+
+        return original_count - len(self.metrics)
+
+    def get_trend(
+        self,
+        metric_type: str,
+        hours: int = 24,
+    ) -> List[Dict[str, Any]]:
+        """Get trend data for a metric."""
+        since = datetime.now() - timedelta(hours=hours)
+        metrics = self.get_metrics(metric_type, since=since)
+
+        # Group by hour
+        hourly_data: Dict[str, List[float]] = defaultdict(list)
+        for m in metrics:
+            hour_key = m.timestamp.strftime("%Y-%m-%d %H:00")
+            hourly_data[hour_key].append(m.value)
+
+        # Calculate hourly averages
+        trend = []
+        for hour, values in sorted(hourly_data.items()):
+            avg = sum(values) / len(values) if values else 0
+            trend.append({
+                "hour": hour,
+                "average": avg,
+                "count": len(values),
+            })
+
+        return trend
+
+    def __repr__(self) -> str:
+        return f"PerformanceMonitor(metrics={len(self.metrics)}, sessions={self._session_stats['total_sessions']})"

src/enhancements/nlp/__init__.py

@@ -0,0 +1,18 @@
+"""
+NLP Enhancement Module
+
+Provides:
+- Contextual embeddings (BERT, RoBERTa)
+- Entity recognition
+- Intent detection
+"""
+
+from .contextual_embeddings import ContextualEmbedder
+from .entity_recognition import EntityRecognizer
+from .intent_detection import IntentDetector
+
+__all__ = [
+    "ContextualEmbedder",
+    "EntityRecognizer",
+    "IntentDetector",
+]

src/enhancements/nlp/contextual_embeddings.py

@@ -0,0 +1,174 @@
+"""
+Contextual Embeddings using BERT/RoBERTa
+
+Provides contextual word embeddings for improved NLP understanding.
+"""
+
+from typing import List, Optional, Dict, Any
+import numpy as np
+from functools import lru_cache
+import torch
+
+
+class ContextualEmbedder:
+    """Generate contextual embeddings using BERT or similar models."""
+
+    def __init__(
+        self,
+        model_name: str = "bert-base-uncased",
+        device: Optional[str] = None,
+        cache_size: int = 1000,
+    ):
+        """
+        Initialize the contextual embedder.
+
+        Args:
+            model_name: Name of the BERT model to use
+            device: Device to run on ('cuda' or 'cpu')
+            cache_size: Maximum number of embeddings to cache
+        """
+        self.model_name = model_name
+        self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
+        self.cache_size = cache_size
+        self._model = None
+        self._tokenizer = None
+        self._embedding_cache: Dict[str, np.ndarray] = {}
+
+    def _load_model(self):
+        """Lazy load the BERT model."""
+        if self._model is None:
+            try:
+                from transformers import AutoModel, AutoTokenizer
+                self._tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+                self._model = AutoModel.from_pretrained(self.model_name)
+                self._model.to(self.device)
+                self._model.eval()
+            except ImportError:
+                raise ImportError("transformers library required. Install: pip install transformers")
+
+    def get_embedding(self, text: str, layer: int = -1) -> np.ndarray:
+        """
+        Get contextual embedding for a text.
+
+        Args:
+            text: Input text
+            layer: Which layer to extract (-1 for last hidden state)
+
+        Returns:
+            Embedding vector as numpy array
+        """
+        # Check cache
+        cache_key = f"{text}:{layer}"
+        if cache_key in self._embedding_cache:
+            return self._embedding_cache[cache_key]
+
+        self._load_model()
+
+        with torch.no_grad():
+            inputs = self._tokenizer(
+                text,
+                return_tensors="pt",
+                padding=True,
+                truncation=True,
+                max_length=512,
+            ).to(self.device)
+
+            outputs = self._model(**inputs)
+            # Get the mean of the last hidden state
+            embedding = outputs.last_hidden_state.mean(dim=1).cpu().numpy()[0]
+
+        # Cache the embedding
+        if len(self._embedding_cache) < self.cache_size:
+            self._embedding_cache[cache_key] = embedding
+
+        return embedding
+
+    def get_embeddings_batch(self, texts: List[str]) -> np.ndarray:
+        """
+        Get embeddings for a batch of texts.
+
+        Args:
+            texts: List of input texts
+
+        Returns:
+            Array of embeddings (num_texts x embedding_dim)
+        """
+        self._load_model()
+
+        with torch.no_grad():
+            inputs = self._tokenizer(
+                texts,
+                return_tensors="pt",
+                padding=True,
+                truncation=True,
+                max_length=512,
+            ).to(self.device)
+
+            outputs = self._model(**inputs)
+            embeddings = outputs.last_hidden_state.mean(dim=1).cpu().numpy()
+
+        return embeddings
+
+    def get_sentence_embedding(self, text: str) -> np.ndarray:
+        """
+        Get a sentence-level embedding using [CLS] token.
+
+        Args:
+            text: Input text
+
+        Returns:
+            Sentence embedding vector
+        """
+        self._load_model()
+
+        with torch.no_grad():
+            inputs = self._tokenizer(
+                text,
+                return_tensors="pt",
+                padding=True,
+                truncation=True,
+                max_length=512,
+            ).to(self.device)
+
+            outputs = self._model(**inputs)
+            # Use [CLS] token embedding (first token)
+            embedding = outputs.last_hidden_state[0, 0].cpu().numpy()
+
+        return embedding
+
+    def compute_similarity(
+        self,
+        text1: str,
+        text2: str,
+        method: str = "cosine",
+    ) -> float:
+        """
+        Compute similarity between two texts.
+
+        Args:
+            text1: First text
+            text2: Second text
+            method: Similarity method ('cosine' or 'dot')
+
+        Returns:
+            Similarity score
+        """
+        emb1 = self.get_embedding(text1)
+        emb2 = self.get_embedding(text2)
+
+        if method == "cosine":
+            # Cosine similarity
+            dot = np.dot(emb1, emb2)
+            norm1 = np.linalg.norm(emb1)
+            norm2 = np.linalg.norm(emb2)
+            return dot / (norm1 * norm2)
+        else:
+            # Dot product
+            return np.dot(emb1, emb2)
+
+    def clear_cache(self) -> None:
+        """Clear the embedding cache."""
+        self._embedding_cache.clear()
+
+    def __repr__(self) -> str:
+        return f"ContextualEmbedder(model='{self.model_name}', device='{self.device}')"

src/enhancements/nlp/entity_recognition.py

@@ -0,0 +1,214 @@
+"""
+Entity Recognition Module
+
+Provides Named Entity Recognition (NER) for extracting entities from text.
+"""
+
+from typing import List, Dict, Optional, Any
+import re
+
+
+class EntityRecognizer:
+    """Extract named entities from text using pattern matching and NER."""
+
+    def __init__(
+        self,
+        use_transformers: bool = True,
+        model_name: str = "dslim/bert-base-NER",
+    ):
+        """
+        Initialize the entity recognizer.
+
+        Args:
+            use_transformers: Whether to use transformer-based NER
+            model_name: Name of the NER model (if using transformers)
+        """
+        self.use_transformers = use_transformers and self._check_transformers()
+        self.model_name = model_name
+        self._model = None
+        self._tokenizer = None
+
+        # Define entity patterns for rule-based fallback
+        self._patterns = {
+            "EMAIL": r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b',
+            "URL": r'https?://[^\s]+',
+            "PHONE": r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b',
+            "IP_ADDRESS": r'\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b',
+            "DATE": r'\b\d{1,2}[/-]\d{1,2}[/-]\d{2,4}\b',
+            "TIME": r'\b\d{1,2}:\d{2}(?:\s*[AaPp][Mm])?\b',
+            "FILE_PATH": r'(?:/[a-zA-Z0-9_.-]+)+',
+            "CODE": r'`[^`]+`',
+            "QUOTED_STRING": r'"[^"]*"|\'[^\']*\'',
+        }
+
+    def _check_transformers(self) -> bool:
+        """Check if transformers is available."""
+        try:
+            import transformers
+            return True
+        except ImportError:
+            return False
+
+    def _load_transformer_model(self):
+        """Lazy load the transformer NER model."""
+        if self._model is None:
+            try:
+                from transformers import AutoTokenizer, AutoModelForTokenClassification
+                self._tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+                self._model = AutoModelForTokenClassification.from_pretrained(self.model_name)
+                self._model.eval()
+            except Exception as e:
+                print(f"Warning: Could not load transformer NER model: {e}")
+                self.use_transformers = False
+
+    def recognize_entities(self, text: str) -> List[Dict[str, Any]]:
+        """
+        Recognize entities in text.
+
+        Args:
+            text: Input text
+
+        Returns:
+            List of entity dictionaries with 'text', 'type', 'start', 'end'
+        """
+        entities = []
+
+        # Use transformer-based NER if available
+        if self.use_transformers:
+            try:
+                entities.extend(self._recognize_transformers(text))
+            except Exception:
+                pass
+
+        # Add rule-based entities
+        entities.extend(self._recognize_patterns(text))
+
+        # Sort by position and remove overlaps
+        entities = self._resolve_overlaps(entities)
+
+        return entities
+
+    def _recognize_transformers(self, text: str) -> List[Dict[str, Any]]:
+        """Use transformer model for NER."""
+        self._load_transformer_model()
+
+        from transformers import pipeline
+        from typing import List, Dict, Any
+
+        # Create pipeline if not exists
+        if not hasattr(self, "_ner_pipeline"):
+            self._ner_pipeline = pipeline(
+                "ner",
+                model=self._model,
+                tokenizer=self._tokenizer,
+                aggregation_strategy="simple",
+            )
+
+        results = self._ner_pipeline(text)
+
+        entities = []
+        for result in results:
+            # Map NER tags to simpler types
+            entity_type = self._map_ner_tag(result.get("entity_group", ""))
+
+            if entity_type:
+                entities.append({
+                    "text": result["word"],
+                    "type": entity_type,
+                    "start": result.get("start", 0),
+                    "end": result.get("end", 0),
+                    "score": result.get("score", 1.0),
+                })
+
+        return entities
+
+    def _map_ner_tag(self, tag: str) -> Optional[str]:
+        """Map NER tags to standard entity types."""
+        tag_mapping = {
+            "PER": "PERSON",
+            "ORG": "ORGANIZATION",
+            "LOC": "LOCATION",
+            "MISC": "MISC",
+        }
+        return tag_mapping.get(tag)
+
+    def _recognize_patterns(self, text: str) -> List[Dict[str, Any]]:
+        """Use pattern matching for entity recognition."""
+        entities = []
+
+        for entity_type, pattern in self._patterns.items():
+            for match in re.finditer(pattern, text):
+                entities.append({
+                    "text": match.group(),
+                    "type": entity_type,
+                    "start": match.start(),
+                    "end": match.end(),
+                    "score": 1.0,
+                })
+
+        return entities
+
+    def _resolve_overlaps(self, entities: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Remove overlapping entities, keeping the higher confidence one."""
+        if not entities:
+            return []
+
+        # Sort by score (descending), then by length (descending)
+        entities = sorted(entities, key=lambda x: (-x.get("score", 1.0), -(x["end"] - x["start"])))
+
+        result = []
+        for entity in entities:
+            overlaps = False
+            for existing in result:
+                if self._overlaps(entity, existing):
+                    overlaps = True
+                    break
+            if not overlaps:
+                result.append(entity)
+
+        # Sort by position
+        result = sorted(result, key=lambda x: x["start"])
+
+        return result
+
+    def _overlaps(self, e1: Dict[str, Any], e2: Dict[str, Any]) -> bool:
+        """Check if two entities overlap."""
+        return not (e1["end"] <= e2["start"] or e2["end"] <= e1["start"])
+
+    def extract_entities_by_type(
+        self,
+        text: str,
+        entity_type: str,
+    ) -> List[str]:
+        """
+        Extract all entities of a specific type.
+
+        Args:
+            text: Input text
+            entity_type: Type of entity to extract
+
+        Returns:
+            List of entity texts
+        """
+        entities = self.recognize_entities(text)
+        return [e["text"] for e in entities if e["type"] == entity_type]
+
+    def get_entity_summary(self, text: str) -> Dict[str, int]:
+        """
+        Get a summary of entity counts by type.
+
+        Args:
+            text: Input text
+
+        Returns:
+            Dictionary mapping entity type to count
+        """
+        entities = self.recognize_entities(text)
+        summary: Dict[str, int] = {}
+        for entity in entities:
+            entity_type = entity["type"]
+            summary[entity_type] = summary.get(entity_type, 0) + 1
+        return summary
+
+    def __repr__(self) -> str:
+        return f"EntityRecognizer(use_transformers={self.use_transformers}, model='{self.model_name}')"

src/enhancements/nlp/intent_detection.py

@@ -0,0 +1,227 @@
+"""
+Intent Detection Module
+
+Detects user intent from text for better conversational understanding.
+"""
+
+from typing import List, Dict, Optional, Any
+import re
+from collections import defaultdict
+
+
+class IntentDetector:
+    """Detect user intent from natural language input."""
+
+    # Common intents with associated keywords and patterns
+    DEFAULT_INTENTS = {
+        "greeting": {
+            "keywords": ["hello", "hi", "hey", "greetings", "good morning", "good afternoon", "good evening"],
+            "patterns": [r"^hi(?: there)?", r"^hello", r"^hey", r"^good (?:morning|afternoon|evening)"],
+        },
+        "farewell": {
+            "keywords": ["bye", "goodbye", "see you", "later", "quit", "exit", "good night"],
+            "patterns": [r"^(?:good )?bye", r"see you", r"(?:good )?night", r"^later"],
+        },
+        "help": {
+            "keywords": ["help", "assist", "support", "can you", "how do i", "how to", "what can you do"],
+            "patterns": [r"^help", r"can you .*(?:help|do)", r"how (?:do|can) i", r"what can you"],
+        },
+        "question": {
+            "keywords": ["what", "how", "why", "when", "where", "who", "which", "?"],
+            "patterns": [r"^(?:what|how|why|when|where|who|which)", r"\?$"],
+        },
+        "code_request": {
+            "keywords": ["write", "code", "create", "implement", "function", "class", "script", "program"],
+            "patterns": [r"(?:write|create|implement|generate) .*(?:code|function|class|script)"],
+        },
+        "debug_request": {
+            "keywords": ["debug", "fix", "error", "bug", "issue", "problem", "broken", "not working", "crash"],
+            "patterns": [r"(?:debug|fix) .*(?:error|bug|issue)", r"(?:there(?:'s| is) an? )?error", r"(?:not working|crash|broken)"],
+        },
+        "refactor": {
+            "keywords": ["refactor", "improve", "optimize", "clean", "simplify", "restructure"],
+            "patterns": [r"(?:refactor|improve|optimize|clean(?: up)?)"],
+        },
+        "explain": {
+            "keywords": ["explain", "describe", "tell me about", "what is", "how does", "what does"],
+            "patterns": [r"(?:explain|describe|tell me about|what is|how does)"],
+        },
+        "search": {
+            "keywords": ["search", "find", "look up", "google", "web search"],
+            "patterns": [r"(?:search|find|look up)"],
+        },
+        "analysis": {
+            "keywords": ["analyze", "review", "check", "test", "evaluate", "compare"],
+            "patterns": [r"(?:analyze|review|check|test|evaluate|compare)"],
+        },
+        "tool_use": {
+            "keywords": ["use tool", "run command", "execute", "shell", "bash"],
+            "patterns": [r"(?:run|execute) .*(?:command|shell)", r"bash", r"shell"],
+        },
+        "learning": {
+            "keywords": ["learn", "teach me", "train", "understand", "study"],
+            "patterns": [r"(?:learn|teach me|train)"],
+        },
+        "feedback": {
+            "keywords": ["feedback", "rating", "opinion", "suggest", "improve", "better"],
+            "patterns": [r"(?:feedback|rating|opinion|suggest|improve)"],
+        },
+        "clarification": {
+            "keywords": ["clarify", "repeat", "restate", "what do you mean", "explain more"],
+            "patterns": [r"(?:clarify|repeat|what do you mean)", r"(?:could you|can you) (?:repeat|clarify)"],
+        },
+    }
+
+    def __init__(
+        self,
+        custom_intents: Optional[Dict[str, Dict[str, List[str]]]] = None,
+        confidence_threshold: float = 0.3,
+    ):
+        """
+        Initialize the intent detector.
+
+        Args:
+            custom_intents: Custom intent definitions
+            confidence_threshold: Minimum confidence for intent detection
+        """
+        self.intents = self.DEFAULT_INTENTS.copy()
+        if custom_intents:
+            self.intents.update(custom_intents)
+        self.confidence_threshold = confidence_threshold
+        self._keyword_cache: Dict[str, float] = {}
+
+    def detect_intent(self, text: str) -> Dict[str, Any]:
+        """
+        Detect the primary intent from text.
+
+        Args:
+            text: Input text
+
+        Returns:
+            Dictionary with 'intent', 'confidence', and 'alternatives'
+        """
+        text_lower = text.lower().strip()
+
+        intent_scores = defaultdict(float)
+
+        # Check each intent
+        for intent_name, intent_config in self.intents.items():
+            # Check keywords
+            for keyword in intent_config.get("keywords", []):
+                if keyword.lower() in text_lower:
+                    intent_scores[intent_name] += 1.0
+
+            # Check patterns
+            for pattern in intent_config.get("patterns", []):
+                if re.search(pattern, text_lower, re.IGNORECASE):
+                    intent_scores[intent_name] += 1.5
+
+        # Normalize scores
+        if intent_scores:
+            max_score = max(intent_scores.values())
+            if max_score > 0:
+                for intent in intent_scores:
+                    intent_scores[intent] /= max_score
+
+        # Sort by score
+        sorted_intents = sorted(
+            intent_scores.items(),
+            key=lambda x: -x[1]
+        )
+
+        if not sorted_intents or sorted_intents[0][1] < self.confidence_threshold:
+            return {
+                "intent": "general",
+                "confidence": 1.0,
+                "alternatives": [],
+            }
+
+        primary_intent = sorted_intents[0][0]
+        alternatives = [
+            {"intent": intent, "confidence": score}
+            for intent, score in sorted_intents[1:4]
+            if score >= self.confidence_threshold
+        ]
+
+        return {
+            "intent": primary_intent,
+            "confidence": sorted_intents[0][1],
+            "alternatives": alternatives,
+        }
+
+    def detect_multiple_intents(self, text: str) -> List[Dict[str, Any]]:
+        """
+        Detect multiple intents from text.
+
+        Args:
+            text: Input text
+
+        Returns:
+            List of intent dictionaries with scores
+        """
+        text_lower = text.lower().strip()
+        intent_scores = defaultdict(float)
+
+        for intent_name, intent_config in self.intents.items():
+            for keyword in intent_config.get("keywords", []):
+                if keyword.lower() in text_lower:
+                    intent_scores[intent_name] += 1.0
+
+            for pattern in intent_config.get("patterns", []):
+                if re.search(pattern, text_lower, re.IGNORECASE):
+                    intent_scores[intent_name] += 1.5
+
+        # Return all intents above threshold
+        results = [
+            {"intent": intent, "confidence": score}
+            for intent, score in intent_scores.items()
+            if score >= self.confidence_threshold
+        ]
+
+        if not results:
+            return [{"intent": "general", "confidence": 1.0}]
+
+        return sorted(results, key=lambda x: -x["confidence"])
+
+    def add_intent(
+        self,
+        intent_name: str,
+        keywords: List[str],
+        patterns: Optional[List[str]] = None,
+    ) -> None:
+        """
+        Add a custom intent.
+
+        Args:
+            intent_name: Name of the intent
+            keywords: List of keywords
+            patterns: List of regex patterns
+        """
+        self.intents[intent_name] = {
+            "keywords": keywords,
+            "patterns": patterns or [],
+        }
+
+    def get_intent_description(self, intent: str) -> str:
+        """Get a description of what an intent means."""
+        descriptions = {
+            "greeting": "User is greeting the assistant",
+            "farewell": "User is saying goodbye",
+            "help": "User is asking for help or assistance",
+            "question": "User is asking a question",
+            "code_request": "User wants code to be written",
+            "debug_request": "User needs help debugging an issue",
+            "refactor": "User wants code to be improved or refactored",
+            "explain": "User wants an explanation of something",
+            "search": "User wants to search for information",
+            "analysis": "User wants code or content analyzed",
+            "tool_use": "User wants to execute a command or tool",
+            "learning": "User wants to learn something",
+            "feedback": "User is providing feedback",
+            "clarification": "User wants clarification on something",
+            "general": "General conversational input",
+        }
+        return descriptions.get(intent, f"Intent: {intent}")
+
+    def __repr__(self) -> str:
+        return f"IntentDetector(num_intents={len(self.intents)}, threshold={self.confidence_threshold})"

src/enhancements/technical/__init__.py

@@ -0,0 +1,18 @@
+"""
+Technical Capabilities Module
+
+Provides advanced technical capabilities:
+- Cloud/DevOps tools
+- Code analysis and debugging
+- Security scanning
+"""
+
+from .devops import DevOpsTools
+from .code_analysis import CodeAnalyzer
+from .debugging import DebuggingAssistant
+
+__all__ = [
+    "DevOpsTools",
+    "CodeAnalyzer",
+    "DebuggingAssistant",
+]

src/enhancements/technical/code_analysis.py

@@ -0,0 +1,223 @@
+"""
+Code Analysis Module
+
+Provides static code analysis and quality checking.
+"""
+
+from typing import Dict, List, Optional, Any, Tuple
+import re
+
+
+class CodeAnalyzer:
+    """Analyze code for quality, complexity, and issues."""
+
+    def __init__(self):
+        """Initialize code analyzer."""
+        pass
+
+    def analyze_complexity(self, code: str) -> Dict[str, Any]:
+        """
+        Analyze code complexity.
+
+        Returns:
+            Dictionary with complexity metrics
+        """
+        lines = code.split('\n')
+
+        # Count functions/methods
+        functions = re.findall(r'def\s+(\w+)', code)
+        methods = re.findall(r'def\s+(\w+)\(self', code)
+        classes = re.findall(r'class\s+(\w+)', code)
+
+        # Count control structures
+        if_statements = len(re.findall(r'\bif\s+', code))
+        for_loops = len(re.findall(r'\bfor\s+', code))
+        while_loops = len(re.findall(r'\bwhile\s+', code))
+        try_blocks = len(re.findall(r'\btry\s+', code))
+
+        # Cyclomatic complexity approximation
+        complexity = 1 + if_statements + for_loops + while_loops + try_blocks
+
+        # Count lines of code
+        loc = len([l for l in lines if l.strip() and not l.strip().startswith('#')])
+
+        return {
+            "lines_of_code": loc,
+            "total_lines": len(lines),
+            "functions": len(functions),
+            "methods": len(methods),
+            "classes": len(classes),
+            "cyclomatic_complexity": complexity,
+            "if_statements": if_statements,
+            "for_loops": for_loops,
+            "while_loops": while_loops,
+        }
+
+    def find_issues(self, code: str, language: str = "python") -> List[Dict[str, Any]]:
+        """
+        Find potential issues in code.
+
+        Args:
+            code: Source code
+            language: Programming language
+
+        Returns:
+            List of issues found
+        """
+        issues = []
+
+        # Common issues for Python
+        if language == "python":
+            issues.extend(self._check_python_issues(code))
+
+        return issues
+
+    def _check_python_issues(self, code: str) -> List[Dict[str, Any]]:
+        """Check for Python-specific issues."""
+        issues = []
+
+        # Check for TODO/FIXME
+        for i, line in enumerate(code.split('\n'), 1):
+            if 'TODO' in line.upper() or 'FIXME' in line.upper():
+                issues.append({
+                    "type": "todo",
+                    "severity": "info",
+                    "line": i,
+                    "message": "TODO/FIXME comment found",
+                })
+
+        # Check for empty except
+        if re.search(r'except\s*:\s*\n\s*pass', code):
+            issues.append({
+                "type": "empty_except",
+                "severity": "warning",
+                "message": "Empty except block - errors are silently ignored",
+            })
+
+        # Check for hardcoded credentials
+        if re.search(r'password\s*=\s*["\']', code, re.IGNORECASE):
+            issues.append({
+                "type": "hardcoded_credentials",
+                "severity": "error",
+                "message": "Potential hardcoded password found",
+            })
+
+        # Check for print statements (debugging)
+        if re.search(r'\bprint\s*\(', code) and not code.startswith('# debug'):
+            issues.append({
+                "type": "debug_print",
+                "severity": "info",
+                "message": "Print statement found - may need removal",
+            })
+
+        # Check for long lines
+        for i, line in enumerate(code.split('\n'), 1):
+            if len(line) > 120:
+                issues.append({
+                    "type": "long_line",
+                    "severity": "info",
+                    "line": i,
+                    "message": f"Line exceeds 120 characters ({len(line)} chars)",
+                })
+
+        # Check for global variables
+        if re.search(r'^([A-Z_][A-Z0-9_]*)\s*=\s*', code, re.MULTILINE):
+            issues.append({
+                "type": "global_variable",
+                "severity": "info",
+                "message": "Potential global variable found",
+            })
+
+        return issues
+
+    def suggest_improvements(self, code: str, language: str = "python") -> List[str]:
+        """Suggest code improvements."""
+        suggestions = []
+        complexity = self.analyze_complexity(code)
+
+        # Complexity suggestions
+        if complexity["cyclomatic_complexity"] > 10:
+            suggestions.append("High cyclomatic complexity - consider breaking into smaller functions")
+
+        if complexity["lines_of_code"] > 500:
+            suggestions.append("Large function - consider splitting into smaller modules")
+
+        # Pattern suggestions
+        if "except:" in code:
+            suggestions.append("Use specific exception types instead of bare except")
+
+        if "print(" in code:
+            suggestions.append("Use logging instead of print statements for production code")
+
+        if "==" in code and "None" in code:
+            suggestions.append("Use 'is None' instead of '== None'")
+
+        if re.search(r'for\s+\w+\s+in\s+range\s*\(\s*len\s*\(', code):
+            suggestions.append("Use enumerate() instead of range(len())")
+
+        return suggestions
+
+    def detect_language(self, code: str) -> str:
+        """Detect programming language from code."""
+        # Python indicators
+        if re.search(r'\bdef\s+\w+\s*\(', code) or re.search(r'\bimport\s+\w+', code):
+            return "python"
+
+        # JavaScript/TypeScript
+        if re.search(r'\bfunction\s+\w+\s*\(', code) or re.search(r'const\s+\w+\s*=', code):
+            return "javascript"
+
+        # Java
+        if re.search(r'\bpublic\s+class\s+\w+', code) or re.search(r'\bSystem\.out\.print', code):
+            return "java"
+
+        # Go
+        if re.search(r'\bpackage\s+main', code) or re.search(r'\bfunc\s+\w+\s*\(', code):
+            return "go"
+
+        # Rust
+        if re.search(r'\bfn\s+\w+\s*\(', code) or re.search(r'\blet\s+mut\s+', code):
+            return "rust"
+
+        # C/C++
+        if re.search(r'#include\s*<', code) or re.search(r'\bint\s+main\s*\(', code):
+            return "c"
+
+        return "unknown"
+
+    def calculate_maintainability_index(self, code: str) -> float:
+        """Calculate maintainability index (0-100)."""
+        complexity = self.analyze_complexity(code)
+        loc = complexity["lines_of_code"]
+
+        if loc == 0:
+            return 100.0
+
+        # Simplified maintainability index
+        # Based on lines of code and complexity
+        base = 100
+        loc_penalty = min(loc / 100, 1) * 20
+        complexity_penalty = min(complexity["cyclomatic_complexity"] / 20, 1) * 30
+
+        index = base - loc_penalty - complexity_penalty
+        return max(0, min(100, index))
+
+    def get_code_summary(self, code: str) -> Dict[str, Any]:
+        """Get comprehensive code summary."""
+        language = self.detect_language(code)
+        complexity = self.analyze_complexity(code)
+        issues = self.find_issues(code, language)
+        suggestions = self.suggest_improvements(code, language)
+        maintainability = self.calculate_maintainability_index(code)
+
+        return {
+            "language": language,
+            "complexity": complexity,
+            "issues": issues,
+            "issue_count": len(issues),
+            "suggestions": suggestions,
+            "maintainability_index": maintainability,
+        }
+
+    def __repr__(self) -> str:
+        return "CodeAnalyzer()"

src/enhancements/technical/debugging.py

@@ -0,0 +1,357 @@
+"""
+Debugging Assistant Module
+
+Provides debugging assistance and error analysis.
+"""
+
+from typing import Dict, List, Optional, Any, Tuple
+import re
+
+
+class DebuggingAssistant:
+    """Helps debug code and analyze errors."""
+
+    # Common error patterns and their explanations
+    ERROR_PATTERNS = {
+        "python": {
+            "SyntaxError": {
+                "description": "Python syntax is invalid",
+                "common_causes": [
+                    "Missing colon after if/for/while/function definitions",
+                    "Mismatched parentheses or brackets",
+                    "Incorrect indentation",
+                    "Using Python 2 syntax in Python 3",
+                ],
+            },
+            "NameError": {
+                "description": "A variable or function name is not defined",
+                "common_causes": [
+                    "Typo in variable name",
+                    "Variable used before assignment",
+                    "Import statement missing",
+                    "Scope issue - variable not accessible",
+                ],
+            },
+            "TypeError": {
+                "description": "Operation applied to wrong type",
+                "common_causes": [
+                    "Trying to concatenate incompatible types",
+                    "Calling a non-callable as a function",
+                    "Passing wrong number of arguments",
+                    "Operation not supported for type",
+                ],
+            },
+            "IndexError": {
+                "description": "List index out of range",
+                "common_causes": [
+                    "Accessing index that doesn't exist",
+                    "Empty list access",
+                    "Off-by-one error",
+                ],
+            },
+            "KeyError": {
+                "description": "Dictionary key not found",
+                "common_causes": [
+                    "Accessing non-existent key",
+                    "Typo in key name",
+                    "Case sensitivity issue",
+                ],
+            },
+            "AttributeError": {
+                "description": "Object has no attribute",
+                "common_causes": [
+                    "Typo in attribute name",
+                    "Object is None when trying to access attribute",
+                    "Wrong type for this operation",
+                ],
+            },
+            "ImportError": {
+                "description": "Cannot import module",
+                "common_causes": [
+                    "Module not installed",
+                    "Circular import",
+                    "Module name typo",
+                    "Missing __init__.py in package",
+                ],
+            },
+            "ZeroDivisionError": {
+                "description": "Division by zero",
+                "common_causes": [
+                    "Dividing by variable that could be zero",
+                    "Modulo by zero",
+                ],
+            },
+            "ValueError": {
+                "description": "Value is inappropriate",
+                "common_causes": [
+                    "Invalid argument to function",
+                    "Conversion failed (e.g., int('abc'))",
+                    "Empty sequence in function expecting content",
+                ],
+            },
+            "IndentationError": {
+                "description": "Incorrect indentation",
+                "common_causes": [
+                    "Mixing tabs and spaces",
+                    "Inconsistent indentation levels",
+                    "Code not aligned properly",
+                ],
+            },
+        },
+        "javascript": {
+            "ReferenceError": {
+                "description": "Variable not defined",
+                "common_causes": [
+                    "Typo in variable name",
+                    "Using let/const before declaration",
+                ],
+            },
+            "TypeError": {
+                "description": "Type operation failed",
+                "common_causes": [
+                    "Calling non-function",
+                    "Cannot read property of undefined/null",
+                ],
+            },
+            "SyntaxError": {
+                "description": "Invalid syntax",
+                "common_causes": [
+                    "Missing closing bracket/parenthesis",
+                    "Invalid string quotes",
+                ],
+            },
+        },
+    }
+
+    def __init__(self):
+        """Initialize debugging assistant."""
+        pass
+
+    def analyze_error(
+        self,
+        error_message: str,
+        language: str = "python",
+    ) -> Dict[str, Any]:
+        """
+        Analyze an error message and provide debugging help.
+
+        Args:
+            error_message: The error message
+            language: Programming language
+
+        Returns:
+            Dictionary with error analysis and suggestions
+        """
+        # Extract error type
+        error_type = self._extract_error_type(error_message, language)
+
+        # Get error info
+        error_info = self.ERROR_PATTERNS.get(language, {}).get(error_type, {
+            "description": "Unknown error",
+            "common_causes": ["Check the error message for clues"],
+        })
+
+        # Generate debugging steps
+        steps = self._generate_debug_steps(error_type, error_message, language)
+
+        # Suggest fixes
+        fixes = self._suggest_fixes(error_type, error_message, language)
+
+        return {
+            "error_type": error_type,
+            "description": error_info["description"],
+            "common_causes": error_info["common_causes"],
+            "debug_steps": steps,
+            "suggested_fixes": fixes,
+        }
+
+    def _extract_error_type(self, error_message: str, language: str) -> str:
+        """Extract error type from error message."""
+        # Look for common error patterns
+        patterns = {
+            "python": [
+                (r"(\w+Error):", 1),
+                (r"(\w+Exception):", 1),
+            ],
+            "javascript": [
+                (r"(\w+Error):", 1),
+                (r"(\w+TypeError):", 1),
+            ],
+        }
+
+        for pattern, group in patterns.get(language, []):
+            match = re.search(pattern, error_message)
+            if match:
+                return match.group(group)
+
+        return "UnknownError"
+
+    def _generate_debug_steps(
+        self,
+        error_type: str,
+        error_message: str,
+        language: str,
+    ) -> List[str]:
+        """Generate debugging steps for the error."""
+        steps = [
+            "1. Read the error message carefully - it tells you what went wrong",
+            "2. Check the line number in the traceback",
+            "3. Look at the context around that line",
+        ]
+
+        if error_type == "NameError":
+            steps.extend([
+                "4. Check if the variable is spelled correctly",
+                "5. Verify the variable is defined before use",
+                "6. Check if you need to import the module",
+            ])
+        elif error_type == "TypeError":
+            steps.extend([
+                "4. Check the types of variables involved",
+                "5. Use print() or logging to debug values",
+                "6. Use type() to check variable types",
+            ])
+        elif error_type == "IndexError":
+            steps.extend([
+                "4. Check the list length before accessing",
+                "5. Consider using try/except for bounds",
+                "6. Check if the list is empty",
+            ])
+        elif error_type == "ImportError":
+            steps.extend([
+                "4. Verify the package is installed (pip list / npm list)",
+                "5. Check the package name is correct",
+                "6. Try reinstalling the package",
+            ])
+
+        return steps
+
+    def _suggest_fixes(
+        self,
+        error_type: str,
+        error_message: str,
+        language: str,
+    ) -> List[str]:
+        """Suggest fixes for the error."""
+        fixes = []
+
+        if error_type == "NameError":
+            fixes.append("Check spelling of all variable/function names")
+            fixes.append("Ensure variable is defined before use")
+            fixes.append("Add necessary import statements")
+        elif error_type == "TypeError":
+            fixes.append("Convert types explicitly if needed")
+            fixes.append("Check you're using the right operators")
+            fixes.append("Verify function accepts the arguments given")
+        elif error_type == "IndexError":
+            fixes.append("Add bounds checking before access")
+            fixes.append("Use .get() for dictionaries")
+            fixes.append("Check if list is empty first")
+        elif error_type == "SyntaxError":
+            fixes.append("Check for missing colons, brackets, quotes")
+            fixes.append("Verify indentation is consistent")
+            fixes.append("Run a linter to find issues")
+
+        return fixes
+
+    def analyze_traceback(self, traceback: str) -> Dict[str, Any]:
+        """
+        Analyze a full traceback.
+
+        Args:
+            traceback: The full error traceback
+
+        Returns:
+            Dictionary with traceback analysis
+        """
+        lines = traceback.split('\n')
+
+        # Extract file and line numbers
+        file_lines = []
+        for line in lines:
+            if 'File "' in line or 'line ' in line:
+                file_lines.append(line.strip())
+
+        # Get the main error
+        error_line = ""
+        for line in lines:
+            if 'Error:' in line or 'Exception:' in line:
+                error_line = line.strip()
+                break
+
+        return {
+            "files_involved": file_lines,
+            "main_error": error_line,
+            "frames": len([l for l in lines if 'File "' in l]),
+        }
+
+    def generate_debug_code(
+        self,
+        error_type: str,
+        code_snippet: str,
+    ) -> str:
+        """Generate debugging code for the error."""
+        debug_templates = {
+            "NameError": f"""# Debug NameError
+# Add debugging print statements
+print(f"Variable value: {{variable_name}}")
+
+# Check if defined
+try:
+    result = {code_snippet}
+except NameError as e:
+    print(f"NameError: {{e}}")""",
+
+            "TypeError": f"""# Debug TypeError
+# Add type checking
+print(f"Type of variable: {{type(variable_name)}}")
+
+# Add type hints for clarity
+def debug_function(variable_name):
+    print(f"Value: {{variable_name}}, Type: {{type(variable_name)}}")
+    return variable_name""",
+
+            "IndexError": f"""# Debug IndexError
+# Add bounds checking
+my_list = []
+
+if len(my_list) > 0:
+    print(f"List has {{len(my_list)}} items")
+    # Access with safety
+    result = my_list[0] if my_list else None""",
+
+            "default": """# General debug approach
+import traceback
+
+try:
+    # Your code here
+    pass
+except Exception as e:
+    print(f"Error: {{e}}")
+    traceback.print_exc()
+    # Add your debugging here"""
+        }
+
+        return debug_templates.get(error_type, debug_templates["default"])
+
+    def suggest_logging(self, code: str) -> str:
+        """Suggest where to add logging statements."""
+        suggestions = []
+
+        # Suggest logging for function calls
+        functions = re.findall(r'def\s+(\w+)\s*\(', code)
+        for func in functions[:3]:  # Limit to 3
+            suggestions.append(f"Add logging at start/end of function '{func}()'")
+
+        # Suggest logging for error handling
+        if "except" in code:
+            suggestions.append("Add logging in exception handlers")
+
+        # Suggest logging for loops
+        if "for " in code:
+            suggestions.append("Add logging in loops to track iterations")
+
+        return suggestions if suggestions else ["Code looks simple, minimal logging needed"]
+
+    def __repr__(self) -> str:
+        return "DebuggingAssistant()"

src/enhancements/technical/devops.py

@@ -0,0 +1,399 @@
+"""
+DevOps Tools Module
+
+Provides cloud and DevOps operation capabilities.
+"""
+
+from typing import Dict, List, Optional, Any
+import re
+
+
+class DevOpsTools:
+    """Cloud and DevOps operation tools."""
+
+    # Cloud provider templates
+    CLOUD_TEMPLATES = {
+        "aws": {
+            "ec2": {
+                "description": "AWS EC2 instance",
+                "template": """# AWS EC2 Instance
+resource "aws_instance" "app_server" {
+  ami           = "ami-0c55b159cbfafe1f0"
+  instance_type = "t3.micro"
+
+  tags = {
+    Name = "Stack2.9-App"
+  }
+}"""
+            },
+            "s3": {
+                "description": "AWS S3 bucket",
+                "template": """# AWS S3 Bucket
+resource "aws_s3_bucket" "data_store" {
+  bucket = "stack29-data-store"
+
+  tags = {
+    Name        = "Stack2.9 Data"
+    Environment = "production"
+  }
+}"""
+            },
+            "lambda": {
+                "description": "AWS Lambda function",
+                "template": """# AWS Lambda Function
+resource "aws_lambda_function" "handler" {
+  filename         = "handler.zip"
+  function_name    = "stack29_handler"
+  role             = aws_iam_role.lambda_role.arn
+  handler          = "index.handler"
+  source_code_hash = filebase64sha256("handler.zip")
+
+  runtime = "python3.9"
+}"""
+            },
+        },
+        "gcp": {
+            "compute": {
+                "description": "GCP Compute Engine",
+                "template": """# GCP Compute Engine
+resource "google_compute_instance" "vm_instance" {
+  name         = "stack29-vm"
+  machine_type = "e2-micro"
+  zone         = "us-central1-a"
+
+  boot_disk {
+    initialize_params {
+      image = "debian-cloud/debian-11"
+    }
+  }
+
+  network_interface {
+    network = "default"
+  }
+}"""
+            },
+            "storage": {
+                "description": "GCP Cloud Storage",
+                "template": """# GCP Cloud Storage
+resource "google_storage_bucket" "bucket" {
+  name          = "stack29-bucket"
+  location      = "US"
+  force_destroy = false
+
+  labels = {
+    environment = "production"
+  }
+}"""
+            },
+        },
+        "docker": {
+            "container": {
+                "description": "Docker container configuration",
+                "template": """# Dockerfile
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application
+COPY . .
+
+# Run application
+CMD ["python", "main.py"]"""
+            },
+            "compose": {
+                "description": "Docker Compose configuration",
+                "template": """# docker-compose.yml
+version: '3.8'
+
+services:
+  app:
+    build: .
+    ports:
+      - "8000:8000"
+    environment:
+      - DATABASE_URL=postgres://db:5432/app
+    depends_on:
+      - db
+      - redis
+
+  db:
+    image: postgres:15
+    environment:
+      - POSTGRES_DB=app
+      - POSTGRES_PASSWORD=secret
+
+  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+"""
+            },
+        },
+        "kubernetes": {
+            "deployment": {
+                "description": "Kubernetes Deployment",
+                "template": """# k8s-deployment.yaml
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: stack29-app
+  labels:
+    app: stack29
+spec:
+  replicas: 3
+  selector:
+    matchLabels:
+      app: stack29
+  template:
+    metadata:
+      labels:
+        app: stack29
+    spec:
+      containers:
+      - name: app
+        image: stack29:latest
+        ports:
+        - containerPort: 8000
+        resources:
+          limits:
+            cpu: "500m"
+            memory: "256Mi"
+"""
+            },
+            "service": {
+                "description": "Kubernetes Service",
+                "template": """# k8s-service.yaml
+apiVersion: v1
+kind: Service
+metadata:
+  name: stack29-service
+spec:
+  selector:
+    app: stack29
+  ports:
+  - protocol: TCP
+    port: 80
+    targetPort: 8000
+  type: LoadBalancer
+"""
+            },
+        },
+    }
+
+    # CI/CD templates
+    CICD_TEMPLATES = {
+        "github_actions": {
+            "description": "GitHub Actions workflow",
+            "template": """# .github/workflows/ci.yml
+name: CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.11'
+
+    - name: Install dependencies
+      run: |
+        pip install -r requirements.txt
+
+    - name: Run tests
+      run: |
+        pytest tests/
+
+    - name: Lint
+      run: |
+        ruff check .
+"""
+        },
+        "gitlab_ci": {
+            "description": "GitLab CI pipeline",
+            "template": """# .gitlab-ci.yml
+stages:
+  - test
+  - build
+  - deploy
+
+test:
+  stage: test
+  script:
+    - pip install -r requirements.txt
+    - pytest tests/
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+
+build:
+  stage: build
+  script:
+    - docker build -t stack29:$CI_COMMIT_SHA .
+  rules:
+    - if: $CI_COMMIT_BRANCH == "main"
+
+deploy:
+  stage: deploy
+  script:
+    - kubectl apply -f k8s/
+  environment:
+    name: production
+  rules:
+    - if: $CI_COMMIT_BRANCH == "main"
+"""
+        },
+    }
+
+    # Infrastructure as Code templates
+    TERRAFORM_VARIABLES = {
+        "description": "Terraform variables",
+        "template": """# variables.tf
+variable "region" {
+  description = "AWS region"
+  type        = string
+  default     = "us-east-1"
+}
+
+variable "environment" {
+  description = "Environment name"
+  type        = string
+  default     = "production"
+}
+
+variable "instance_type" {
+  description = "EC2 instance type"
+  type        = string
+  default     = "t3.micro"
+}
+"""
+    }
+
+    def __init__(self):
+        """Initialize DevOps tools."""
+        pass
+
+    def get_cloud_template(
+        self,
+        provider: str,
+        service: str,
+    ) -> Optional[str]:
+        """Get a cloud infrastructure template."""
+        return self.CLOUD_TEMPLATES.get(provider, {}).get(service, {}).get("template")
+
+    def get_cicd_template(self, platform: str) -> Optional[str]:
+        """Get a CI/CD pipeline template."""
+        return self.CICD_TEMPLATES.get(platform, {}).get("template")
+
+    def list_available_templates(self) -> Dict[str, List[str]]:
+        """List all available templates."""
+        return {
+            "cloud_providers": list(self.CLOUD_TEMPLATES.keys()),
+            "cicd": list(self.CICD_TEMPLATES.keys()),
+        }
+
+    def generate_kubernetes_manifest(
+        self,
+        app_name: str,
+        image: str,
+        replicas: int = 3,
+        port: int = 8000,
+    ) -> str:
+        """Generate a Kubernetes deployment manifest."""
+        return f"""apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: {app_name}
+  labels:
+    app: {app_name}
+spec:
+  replicas: {replicas}
+  selector:
+    matchLabels:
+      app: {app_name}
+  template:
+    metadata:
+      labels:
+        app: {app_name}
+    spec:
+      containers:
+      - name: {app_name}
+        image: {image}
+        ports:
+        - containerPort: {port}
+        resources:
+          limits:
+            cpu: "1000m"
+            memory: "512Mi"
+          requests:
+            cpu: "100m"
+            memory: "128Mi"
+---
+
+apiVersion: v1
+kind: Service
+metadata:
+  name: {app_name}-service
+spec:
+  selector:
+    app: {app_name}
+  ports:
+  - protocol: TCP
+    port: 80
+    targetPort: {port}
+  type: LoadBalancer
+"""
+
+    def generate_dockerfile(
+        self,
+        language: str = "python",
+        version: str = "3.11",
+        port: int = 8000,
+    ) -> str:
+        """Generate a Dockerfile."""
+        base_images = {
+            "python": f"python:{version}-slim",
+            "node": f"node:{version}-slim",
+            "go": f"golang:{version}",
+            "rust": f"rust:{version}-slim",
+        }
+        base = base_images.get(language, f"python:{version}-slim")
+
+        return f"""FROM {base}
+
+WORKDIR /app
+
+# Install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application
+COPY . .
+
+# Expose port
+EXPOSE {port}
+
+# Run application
+CMD ["python", "main.py"]
+"""
+
+    def parse_docker_compose(self, compose_content: str) -> Dict[str, Any]:
+        """Parse docker-compose content to extract services."""
+        services = re.findall(r'^  (\w+):$', compose_content, re.MULTILINE)
+        return {"services": services, "count": len(services)}
+
+    def __repr__(self) -> str:
+        templates = self.list_available_templates()
+        return f"DevOpsTools(cloud={templates['cloud_providers']}, cicd={templates['cicd']})"

test_enhancements.py

@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+"""
+Quick test script to verify enhancement modules work.
+Run this before the full chat to check all modules are functioning.
+"""
+
+import sys
+from pathlib import Path
+
+# Add src to path
+sys.path.insert(0, str(Path(__file__).parent / "src"))
+
+print("=" * 50)
+print("Testing Stack 2.9 Enhancement Modules")
+print("=" * 50)
+
+# Test 1: Config
+print("\n[1] Testing Configuration...")
+from enhancements import get_config, EnhancementConfig
+config = get_config()
+print(f"  ✓ Config loaded: NLP={config.nlp.use_bert_embeddings}, RAG={config.knowledge_graph.rag_enabled}")
+
+# Test 2: NLP Modules
+print("\n[2] Testing NLP Modules...")
+from enhancements.nlp import IntentDetector, EntityRecognizer
+
+# Test Intent Detection
+intent_detector = IntentDetector()
+test_intents = [
+    "Write a function to calculate fibonacci",
+    "Help me debug this error",
+    "Explain what is Python",
+    "Hello there!",
+]
+print("  Intent Detection:")
+for text in test_intents:
+    result = intent_detector.detect_intent(text)
+    print(f"    '{text[:30]}...' → {result['intent']} ({result['confidence']:.2f})")
+
+# Test Entity Recognition
+entity_recognizer = EntityRecognizer()
+test_entities = [
+    "My email is test@example.com and I live in New York",
+    "Visit https://github.com for code",
+    "Call me at 555-123-4567",
+]
+print("  Entity Recognition:")
+for text in test_entities:
+    entities = entity_recognizer.recognize_entities(text)
+    print(f"    '{text[:30]}...' → {[e['type'] for e in entities]}")
+
+# Test 3: Knowledge Graph
+print("\n[3] Testing Knowledge Graph...")
+from enhancements.knowledge_graph import KnowledgeGraph, RAGEngine
+
+kg = KnowledgeGraph()
+kg.add_entity("Python", "language", {"version": "3.11"})
+kg.add_entity("Stack2.9", "ai_assistant", {"version": "2.9"})
+kg.add_relationship("Stack2.9", "Python", "uses")
+print(f"  ✓ Knowledge Graph: {kg.get_stats()}")
+
+# Test RAG
+rag = RAGEngine()
+rag.add_document("doc1", "Python is a programming language.")
+rag.add_document("doc2", "Stack 2.9 is an AI coding assistant.")
+results = rag.retrieve("Tell me about Python")
+print(f"  ✓ RAG Retrieval: {len(results)} docs found")
+
+# Test 4: Emotional Intelligence
+print("\n[4] Testing Emotional Intelligence...")
+from enhancements.emotional_intelligence import SentimentAnalyzer, EmpathyEngine
+
+sentiment = SentimentAnalyzer()
+test_sentiments = [
+    "This is amazing! I love it!",
+    "I'm frustrated with this problem",
+    "Can you help me?",
+]
+print("  Sentiment Analysis:")
+for text in test_sentiments:
+    result = sentiment.analyze_sentiment(text)
+    print(f"    '{text[:30]}...' → {result['sentiment']} ({result['emotion_tone']})")
+
+empathy = EmpathyEngine()
+test_response = "Here's your code:"
+empathetic = empathy.generate_empathetic_response(
+    "I'm having trouble with my code",
+    test_response
+)
+print(f"  ✓ Empathy Engine: Modified response with prefix")
+
+# Test 5: Collaboration
+print("\n[5] Testing Collaboration...")
+from enhancements.collaboration import ConversationStateManager, MCPIntegration
+
+conv_mgr = ConversationStateManager()
+session_id = conv_mgr.create_session()
+conv_mgr.add_message("user", "Hello AI!")
+conv_mgr.add_message("assistant", "Hello! How can I help?")
+history = conv_mgr.get_conversation_history()
+print(f"  ✓ Conversation Manager: {len(history)} messages in session")
+
+mcp = MCPIntegration()
+tools = mcp.list_tools()
+print(f"  ✓ MCP Integration: {len(tools)} tools registered")
+
+# Test 6: Learning
+print("\n[6] Testing Learning System...")
+from enhancements.learning import FeedbackCollector, PerformanceMonitor
+
+feedback = FeedbackCollector(storage_path="data/test_feedback")
+fb_id = feedback.add_thumbs_up("Test message", "Test response")
+stats = feedback.get_statistics()
+print(f"  ✓ Feedback Collector: {stats['total']} entries")
+
+perf = PerformanceMonitor(storage_path="data/test_performance")
+perf.record_response_time(0.5)
+perf.record_successful_interaction()
+summary = perf.get_summary()
+print(f"  ✓ Performance Monitor: avg response {summary['average_response_time']:.2f}s")
+
+# Summary
+print("\n" + "=" * 50)
+print("All Enhancement Modules Tested Successfully!")
+print("=" * 50)
+print("\nTo run the enhanced chat:")
+print("  python enhanced_chat.py")
+print("\nOptions:")
+print("  --no-bert      Disable BERT embeddings")
+print("  --no-rag       Disable RAG")
+print("  --no-empathy   Disable emotional intelligence")