Update modules/orchestrator.py

modules/orchestrator.py

@@ -9,240 +9,204 @@ import time
 import psutil
 import threading
 import functools
-import importlib.util
-from abc import ABC, abstractmethod
+import re
 from datetime import datetime
-from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
 from typing import Dict, Any, List, Optional, Union, Callable
 from dataclasses import dataclass, field
 from fastapi import APIRouter, Form, Request
 
+# Pygments for Colorful Coding
+from pygments import highlight
+from pygments.lexers import get_lexer_by_name, PythonLexer
+from pygments.formatters import HtmlFormatter
+
 # =================================================================
-# 1. ENTERPRISE CONFIGURATION & ARCHITECTURE CONSTANTS
+# 1. ADVANCED ENTERPRISE CONFIGURATION
 # =================================================================
 @dataclass
 class MasterConfig:
-    version: str = "3.5.0-Enterprise"
+    version: str = "4.0.0-Titan"
     max_workers: int = os.cpu_count() or 4
-    timeout: int = 120
+    timeout: int = 150
     memory_limit_mb: int = 1024
-    db_path: str = "data/system_state.json"
-    log_file: str = "logs/orchestrator.log"
-    diagnostics_log: str = "logs/diagnostics.log"
-    enable_telemetry: bool = True
-    username: str = "AumCore AI"
+    log_file: str = "logs/orchestrator_titan.log"
+    username: str = "AumCoreAI"
     repo_name: str = "aumcore-m7b-docker"
+    # Styling for Colorful Output
+    code_style: str = "monokai" 
 
 # =================================================================
-# 2. ADVANCED LOGGING & AUDIT SYSTEM
+# 2. PROFESSIONAL AUDIT & LOGGING SYSTEM
 # =================================================================
-class AumAuditLogger:
-    """Professional Audit System with multi-sink capability"""
-    def __init__(self, name: str, log_file: str):
+class AumAuditSystem:
+    def __init__(self, log_file: str):
         if not os.path.exists('logs'): os.makedirs('logs')
-        self.logger = logging.getLogger(name)
+        self.logger = logging.getLogger("TitanOrchestrator")
         self.logger.setLevel(logging.DEBUG)
-        
-        # Prevent duplicate handlers
         if not self.logger.handlers:
-            fmt = logging.Formatter('%(asctime)s | [%(levelname)s] | %(name)s | %(message)s')
-            
+            formatter = logging.Formatter('%(asctime)s | [%(levelname)s] | %(message)s')
             fh = logging.FileHandler(log_file)
-            fh.setFormatter(fmt)
+            fh.setFormatter(formatter)
             self.logger.addHandler(fh)
-            
             ch = logging.StreamHandler()
-            ch.setFormatter(fmt)
+            ch.setFormatter(formatter)
             self.logger.addHandler(ch)
 
-    def info(self, msg): self.logger.info(msg)
-    def error(self, msg): self.logger.error(msg)
-    def warn(self, msg): self.logger.warning(msg)
-    def critical(self, msg): self.logger.critical(msg)
+    def log_event(self, level: str, msg: str):
+        if level == "info": self.logger.info(msg)
+        elif level == "error": self.logger.error(msg)
+        elif level == "warn": self.logger.warning(msg)
+
+# =================================================================
+# 3. COLORFUL FORMATTING ENGINE (PYGMENTS INTEGRATION)
+# =================================================================
+class ColorfulFormatter:
+    """The Engine that kills Black & White responses"""
+    def __init__(self, style: str):
+        self.formatter = HtmlFormatter(style=style, noclasses=True, nowrap=True)
+        self.style_defs = HtmlFormatter(style=style).get_style_defs('.highlight')
+
+    def inject_colors(self, text: str) -> str:
+        """Finds markdown blocks and injects colorful HTML"""
+        # Pattern to match ```lang \n code \n ```
+        pattern = r"```(\w+)\n(.*?)\n```"
+        
+        def replacer(match):
+            lang = match.group(1)
+            code = match.group(2)
+            try:
+                lexer = get_lexer_by_name(lang, stripall=True)
+            except:
+                lexer = PythonLexer(stripall=True)
+            
+            colored_code = highlight(code, lexer, self.formatter)
+            return (
+                f'<div style="background-color: #272822; color: #f8f8f2; border-radius: 10px; '
+                f'padding: 15px; margin: 10px 0; font-family: Consolas, monospace; overflow-x: auto; '
+                f'border: 1px solid #444;">'
+                f'<div style="color: #66d9ef; margin-bottom: 5px; font-size: 0.8em; '
+                f'text-transform: uppercase;">{lang} Editor</div>'
+                f'<pre style="margin: 0;">{colored_code}</pre></div>'
+            )
+
+        return re.sub(pattern, replacer, text, flags=re.DOTALL)
 
 # =================================================================
-# 3. AI PIPELINE: THE BRAIN OF THE ORCHESTRATOR
+# 4. INTELLIGENT PIPELINE MANAGER
 # =================================================================
-class AIPipelineManager:
-    """Manages the flow between Intelligence, Reviewer, and Formatter"""
-    def __init__(self, client, config: MasterConfig, logger: AumAuditLogger):
+class PipelineManager:
+    def __init__(self, client, logger: AumAuditSystem):
         self.client = client
-        self.config = config
         self.logger = logger
+        self.formatter = ColorfulFormatter("monokai")
 
-    async def run_professional_workflow(self, message: str) -> str:
-        """Sequential Execution of AI Modules"""
-        req_id = f"AI-{uuid.uuid4().hex[:6]}"
-        self.logger.info(f"[{req_id}] Initiating Professional Coding Workflow")
+    async def execute_workflow(self, message: str) -> str:
+        """Main AI Flow: Reason -> Generate -> Review -> Colorize"""
+        self.logger.log_event("info", f"Processing Request: {message[:50]}...")
+        
+        # 1. Logic Expansion (Call Intelligence if available)
+        enhanced_prompt = await self._call_module("code_intelligence", "analyze_logic", message)
+        
+        # 2. Master Generation
+        raw_ai_response = await self._generate_core_ai(enhanced_prompt or message)
         
+        # 3. Code Review (Call Reviewer if available)
+        reviewed_response = await self._call_module("code_reviewer", "review_code", raw_ai_response)
+        
+        # 4. Final Formatting (Injection of Colors)
+        final_output = self.formatter.inject_colors(reviewed_response or raw_ai_response)
+        
+        return final_output
+
+    async def _generate_core_ai(self, prompt: str) -> str:
+        system_instructions = (
+            "You are the Titan-Class AI Architect of AumCore. "
+            "You write PRODUCTION-READY code with PEP 8 standards. "
+            "Always wrap code in ```python blocks. Never use simple text for logic. "
+            "Think step-by-step and provide clean, modular, and well-documented scripts."
+        )
         try:
-            # Step 1: Logic Analysis (Calling Code Intelligence)
-            logic_data = await self._invoke_module_feature("code_intelligence", "analyze_logic", message)
-            
-            # Step 2: Expert Persona Generation
-            raw_response = await self._generate_with_expert_persona(logic_data or message)
-            
-            # Step 3: Code Quality Review
-            reviewed_code = await self._invoke_module_feature("code_reviewer", "review_code", raw_response)
-            final_code = reviewed_code if reviewed_code else raw_response
-            
-            # Step 4: Formatting & Beautification
-            formatted_res = await self._invoke_module_feature("code_formatter", "format_response", final_code)
-            
-            self.logger.info(f"[{req_id}] Workflow completed successfully.")
-            return formatted_res if formatted_res else final_code
-
+            # Use executor for blocking Groq call
+            loop = asyncio.get_event_loop()
+            res = await loop.run_in_executor(None, lambda: self.client.chat.completions.create(
+                model="llama-3.3-70b-versatile",
+                messages=[{"role": "system", "content": system_instructions}, {"role": "user", "content": prompt}],
+                temperature=0.3,
+                max_tokens=3000
+            ))
+            return res.choices[0].message.content
         except Exception as e:
-            self.logger.error(f"[{req_id}] Workflow Crash: {str(e)}")
-            return f"❌ Pipeline Error: {str(e)}"
+            self.logger.log_event("error", f"LLM Crash: {e}")
+            return f"❌ System Error in Generation: {str(e)}"
 
-    async def _invoke_module_feature(self, mod_name: str, method_name: str, data: Any):
-        """Safely call a module if it exists in sys.modules"""
+    async def _call_module(self, mod_name: str, method: str, data: str):
         module = sys.modules.get(mod_name)
-        if module and hasattr(module, method_name):
+        if module and hasattr(module, method):
             try:
-                self.logger.info(f"Calling {mod_name}.{method_name}")
-                func = getattr(module, method_name)
-                if asyncio.iscoroutinefunction(func):
-                    return await func(data)
-                return func(data)
+                func = getattr(module, method)
+                return await func(data) if asyncio.iscoroutinefunction(func) else func(data)
             except Exception as e:
-                self.logger.warn(f"Failed to execute {mod_name}: {e}")
+                self.logger.log_event("warn", f"Module {mod_name} failed: {e}")
         return None
 
-    async def _generate_with_expert_persona(self, prompt: str) -> str:
-        """Calls Groq with the Senior Developer System Prompt"""
-        if not self.client:
-            return "Groq Client Not Available"
-            
-        system_prompt = (
-            f"You are the Core AI Engine of {self.config.username}. "
-            "Your task is to provide TOP-TIER PROFESSIONAL CODING. "
-            "Rules: 1. Always use PEP 8. 2. Include robust error handling. "
-            "3. Use type hints. 4. Output MUST be in beautiful Markdown with language tags."
-        )
-        
-        try:
-            loop = asyncio.get_event_loop()
-            response = await loop.run_in_executor(
-                None, 
-                lambda: self.client.chat.completions.create(
-                    model="llama-3.3-70b-versatile",
-                    messages=[
-                        {"role": "system", "content": system_prompt},
-                        {"role": "user", "content": prompt}
-                    ],
-                    temperature=0.1,
-                    max_tokens=2048
-                )
-            )
-            return response.choices[0].message.content
-        except Exception as e:
-            raise Exception(f"LLM Generation Failed: {str(e)}")
-
 # =================================================================
-# 4. RESOURCE & DIAGNOSTICS ENGINE
+# 5. DIAGNOSTICS & SYSTEM MONITOR
 # =================================================================
-class AumDiagnostics:
-    def __init__(self, config: MasterConfig, logger: AumAuditLogger):
-        self.config = config
-        self.logger = logger
-
-    async def get_system_report(self) -> Dict:
-        """Generates a deep-dive system health report"""
+class TitanDiagnostics:
+    @staticmethod
+    async def run_check():
         vmem = psutil.virtual_memory()
-        cpu = psutil.cpu_percent(interval=0.5)
-        
-        report = {
-            "timestamp": datetime.now().isoformat(),
-            "os": sys.platform,
-            "python_version": sys.version,
-            "resources": {
-                "cpu_usage": f"{cpu}%",
-                "memory_used": f"{vmem.percent}%",
-                "memory_available_gb": round(vmem.available / (1024**3), 2)
-            },
-            "active_modules": [m for m in sys.modules if m.startswith('code_') or m == 'orchestrator'],
-            "status": "EXCELLENT" if vmem.percent < 80 else "WARNING"
+        return {
+            "status": "Healthy",
+            "cpu_load": f"{psutil.cpu_percent()}%",
+            "memory": f"{vmem.percent}% used",
+            "uptime": f"{round(time.time() - psutil.boot_time())}s"
         }
-        return report
 
 # =================================================================
-# 5. THE MASTER ORCHESTRATOR CLASS
+# 6. MASTER ORCHESTRATOR INTERFACE
 # =================================================================
 class AumCoreMaster:
-    """The High-Level Controller that integrates everything"""
-    def __init__(self, client=None):
+    def __init__(self, client):
         self.config = MasterConfig()
-        self.logger = AumAuditLogger("Master", self.config.log_file)
-        self.diagnostics = AumDiagnostics(self.config, self.logger)
-        self.pipeline = AIPipelineManager(client, self.config, self.logger)
-        self.is_active = True
-        
-        # Graceful shutdown handling
-        signal.signal(signal.SIGINT, self._shutdown_handler)
-
-    def _shutdown_handler(self, sig, frame):
-        self.logger.warn("Shutdown signal received. Finalizing tasks...")
-        self.is_active = False
-
-    async def process_professional_request(self, message: str) -> str:
-        """Entry point for app.py chat logic"""
-        # Feature detection: Is this a coding task?
-        coding_triggers = ["code", "python", "script", "function", "fix error", "build"]
-        is_coding = any(t in message.lower() for t in coding_triggers)
+        self.audit = AumAuditSystem(self.config.log_file)
+        self.pipeline = PipelineManager(client, self.audit)
+        self.is_running = True
+
+    async def handle_request(self, message: str) -> str:
+        # Check for code intent
+        coding_triggers = ["code", "python", "script", "build", "debug", "function"]
+        if any(word in message.lower() for word in coding_triggers):
+            return await self.pipeline.execute_workflow(message)
         
-        if is_coding:
-            return await self.pipeline.run_professional_workflow(message)
-        
-        # Fallback to standard logic if not coding
-        return "Not a coding request. Handled by fallback."
+        # Standard Chat with basic color injection
+        raw_res = await self.pipeline._generate_core_ai(message)
+        return self.pipeline.formatter.inject_colors(raw_res)
 
 # =================================================================
-# 6. FASTAPI MODULE REGISTRATION (INTERFACE)
+# 7. FASTAPI REGISTRATION (THE BRIDGE)
 # =================================================================
 def register_module(app, client, username):
-    """
-    NEVER CHANGE THIS: This connects Orchestrator to app.py
-    """
     master = AumCoreMaster(client)
-    router = APIRouter(prefix="/system", tags=["Core Orchestration"])
-
-    @router.get("/status")
-    async def get_status():
-        report = await master.diagnostics.get_system_report()
-        return {"success": True, "report": report}
+    router = APIRouter(prefix="/system")
 
     @router.post("/orchestrate")
-    async def orchestrate_task(message: str = Form(...)):
-        """The primary endpoint for professional AI logic"""
-        response = await master.process_professional_request(message)
+    async def process_task(message: str = Form(...)):
+        response = await master.handle_request(message)
         return {"response": response}
 
-    @router.get("/health/deep")
-    async def deep_health():
-        return {
-            "status": "online",
-            "uptime": "active",
-            "module_version": master.config.version,
-            "repo": master.config.repo_name
-        }
+    @router.get("/titan/health")
+    async def health():
+        return await TitanDiagnostics.run_check()
 
-    # Dynamic Registration
     app.include_router(router)
-    
-    # Store master in app state for access if needed
     app.state.orchestrator = master
-    
-    print("=" * 50)
-    print(f"🚀 {master.config.version} DEPLOYED")
-    print(f"✅ Professional Coding Pipeline: ACTIVE")
-    print(f"✅ System Diagnostics: ONLINE")
-    print("=" * 50)
 
-# =================================================================
-# 7. STANDALONE BOOTSTRAP (For testing)
-# =================================================================
+    print("\n" + "="*60)
+    print(f"🚀 TITAN ORCHESTRATOR v{master.config.version} ONLINE")
+    print(f"✅ Colorful Injection Engine: READY")
+    print(f"✅ Expert Coding Pipeline: ACTIVE")
+    print("="*60 + "\n")
+
 if __name__ == "__main__":
-    print("Starting AumCore Orchestrator in standalone mode...")
-    # Standalone testing logic here
+    print("Orchestrator testing mode...")