Update modules/orchestrator.py

modules/orchestrator.py

@@ -15,198 +15,197 @@ 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. ADVANCED ENTERPRISE CONFIGURATION
+# 1. TITAN ENTERPRISE CONFIGURATION (2.0)
 # =================================================================
 @dataclass
 class MasterConfig:
-    version: str = "4.0.0-Titan"
+    version: str = "4.2.0-Titan-Stable"
     max_workers: int = os.cpu_count() or 4
     timeout: int = 150
     memory_limit_mb: int = 1024
     log_file: str = "logs/orchestrator_titan.log"
+    diagnostics_log: str = "logs/titan_diagnostics.log"
     username: str = "AumCoreAI"
     repo_name: str = "aumcore-m7b-docker"
-    # Styling for Colorful Output
-    code_style: str = "monokai" 
+    branch: str = "main"
 
 # =================================================================
-# 2. PROFESSIONAL AUDIT & LOGGING SYSTEM
+# 2. HIGH-LEVEL AUDIT SYSTEM
 # =================================================================
-class AumAuditSystem:
-    def __init__(self, log_file: str):
+class TitanAudit:
+    """Enterprise logging for tracking every AI decision"""
+    def __init__(self, config: MasterConfig):
         if not os.path.exists('logs'): os.makedirs('logs')
-        self.logger = logging.getLogger("TitanOrchestrator")
+        self.logger = logging.getLogger("TitanMaster")
         self.logger.setLevel(logging.DEBUG)
         if not self.logger.handlers:
-            formatter = logging.Formatter('%(asctime)s | [%(levelname)s] | %(message)s')
-            fh = logging.FileHandler(log_file)
-            fh.setFormatter(formatter)
+            fmt = logging.Formatter('%(asctime)s | [%(levelname)s] | %(message)s')
+            fh = logging.FileHandler(config.log_file)
+            fh.setFormatter(fmt)
             self.logger.addHandler(fh)
             ch = logging.StreamHandler()
-            ch.setFormatter(formatter)
+            ch.setFormatter(fmt)
             self.logger.addHandler(ch)
 
-    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)
+    def info(self, msg): self.logger.info(msg)
+    def error(self, msg): self.logger.error(msg)
+    def warn(self, msg): self.logger.warning(msg)
 
 # =================================================================
-# 4. INTELLIGENT PIPELINE MANAGER
+# 3. CORE LOGIC PIPELINE (The Brain)
 # =================================================================
-class PipelineManager:
-    def __init__(self, client, logger: AumAuditSystem):
+class TitanPipeline:
+    """Manages AI Modules and ensures Professional Output"""
+    def __init__(self, client, config: MasterConfig, audit: TitanAudit):
         self.client = client
-        self.logger = logger
-        self.formatter = ColorfulFormatter("monokai")
+        self.config = config
+        self.audit = audit
 
-    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."
+    async def execute_task(self, user_query: str) -> str:
+        """The Master Sequence: Reason -> Gen -> Style"""
+        req_id = f"AUM-{uuid.uuid4().hex[:6].upper()}"
+        self.audit.info(f"Task {req_id} started: {user_query[:30]}")
+
+        try:
+            # Step 1: Intelligence Hook (Logic Check)
+            logic_data = await self._call_module("code_intelligence", "analyze_logic", user_query)
+            
+            # Step 2: Expert Generation (With Hardcoded Persona)
+            # IMPORTANT: We use clean Markdown here to keep your COPY BUTTON active
+            final_response = await self._generate_with_expert_persona(logic_data or user_query)
+            
+            # Step 3: Reviewer Hook (Bug detection)
+            reviewed_data = await self._call_module("code_reviewer", "review_code", final_response)
+            
+            self.audit.info(f"Task {req_id} completed successfully.")
+            return reviewed_data or final_response
+
+        except Exception as e:
+            self.audit.error(f"Pipeline Crash on {req_id}: {str(e)}")
+            return f"❌ **System Error:** {str(e)}"
+
+    async def _generate_with_expert_persona(self, prompt: str) -> str:
+        """Calls Groq with Strict Senior Developer Persona"""
+        if not self.client: return "Groq client is offline."
+
+        system_instruction = (
+            "YOU ARE A SENIOR PRINCIPAL ENGINEER AT AUMCORE AI. "
+            "YOUR GOAL: PROVIDE ENTERPRISE-GRADE PYTHON SOLUTIONS. "
+            "RULES: "
+            "1. ALWAYS USE STANDARD MARKDOWN CODE BLOCKS (```python ... ```). "
+            "2. NEVER CHIPKAO (STICK) IMPORTS; USE PROPER NEWLINES. "
+            "3. INCLUDE TYPE HINTS, DOCSTRINGS, AND TRY-EXCEPT BLOCKS. "
+            "4. DO NOT USE MANUAL HTML DIVS; KEEP IT NATIVE MARKDOWN FOR THE COPY BUTTON. "
+            "5. OUTPUT MUST BE CLEAN, WELL-SPACED, AND LOGICAL."
         )
+
         try:
-            # Use executor for blocking Groq call
             loop = asyncio.get_event_loop()
-            res = await loop.run_in_executor(None, lambda: self.client.chat.completions.create(
+            response = 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,
+                messages=[
+                    {"role": "system", "content": system_instruction},
+                    {"role": "user", "content": prompt}
+                ],
+                temperature=0.2,
                 max_tokens=3000
             ))
-            return res.choices[0].message.content
+            return response.choices[0].message.content
         except Exception as e:
-            self.logger.log_event("error", f"LLM Crash: {e}")
-            return f"❌ System Error in Generation: {str(e)}"
+            raise Exception(f"Titan Generation Failed: {str(e)}")
 
     async def _call_module(self, mod_name: str, method: str, data: str):
+        """Dynamic cross-module communication"""
         module = sys.modules.get(mod_name)
         if module and hasattr(module, method):
             try:
                 func = getattr(module, method)
-                return await func(data) if asyncio.iscoroutinefunction(func) else func(data)
+                if asyncio.iscoroutinefunction(func):
+                    return await func(data)
+                return func(data)
             except Exception as e:
-                self.logger.log_event("warn", f"Module {mod_name} failed: {e}")
+                self.audit.warn(f"Module {mod_name} execution error: {e}")
         return None
 
 # =================================================================
-# 5. DIAGNOSTICS & SYSTEM MONITOR
+# 4. SYSTEM HEALTH & DIAGNOSTICS (Updated)
 # =================================================================
-class TitanDiagnostics:
-    @staticmethod
-    async def run_check():
-        vmem = psutil.virtual_memory()
+class TitanMonitor:
+    def __init__(self, config: MasterConfig):
+        self.config = config
+
+    async def run_diagnostics(self) -> Dict:
+        """Deep system check"""
+        process = psutil.Process(os.getpid())
         return {
-            "status": "Healthy",
-            "cpu_load": f"{psutil.cpu_percent()}%",
-            "memory": f"{vmem.percent}% used",
-            "uptime": f"{round(time.time() - psutil.boot_time())}s"
+            "uptime": f"{round(time.time() - psutil.boot_time())}s",
+            "memory_usage": f"{process.memory_info().rss / 1024 / 1024:.2f} MB",
+            "cpu_percent": f"{psutil.cpu_percent()}%",
+            "active_threads": threading.active_count(),
+            "python_env": sys.version.split()[0]
         }
 
 # =================================================================
-# 6. MASTER ORCHESTRATOR INTERFACE
+# 5. THE MASTER ORCHESTRATOR CLASS
 # =================================================================
 class AumCoreMaster:
-    def __init__(self, client):
+    """The Ultimate Controller of the AI Ecosystem"""
+    def __init__(self, client=None):
         self.config = MasterConfig()
-        self.audit = AumAuditSystem(self.config.log_file)
-        self.pipeline = PipelineManager(client, self.audit)
+        self.audit = TitanAudit(self.config)
+        self.pipeline = TitanPipeline(client, self.config, self.audit)
+        self.monitor = TitanMonitor(self.config)
         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)
         
-        # Standard Chat with basic color injection
-        raw_res = await self.pipeline._generate_core_ai(message)
-        return self.pipeline.formatter.inject_colors(raw_res)
+        # OS Signal handling
+        signal.signal(signal.SIGINT, self._handle_exit)
+
+    def _handle_exit(self, sig, frame):
+        self.audit.warn("Titan is shutting down gracefully...")
+        self.is_running = False
+
+    async def process_request(self, message: str) -> str:
+        """Public entry point for professional chat"""
+        # Detection logic
+        triggers = ["code", "script", "python", "build", "create", "fix"]
+        if any(t in message.lower() for t in triggers):
+            return await self.pipeline.execute_task(message)
+        
+        # Fallback for normal conversation (Still runs through Titan Brain)
+        return await self.pipeline.execute_task(f"Chat mode: {message}")
 
 # =================================================================
-# 7. FASTAPI REGISTRATION (THE BRIDGE)
+# 6. FASTAPI MODULE REGISTRATION
 # =================================================================
 def register_module(app, client, username):
+    """Integrates Titan Orchestrator into the FastAPI Space"""
     master = AumCoreMaster(client)
-    router = APIRouter(prefix="/system")
+    router = APIRouter(prefix="/system", tags=["Titan Core"])
 
     @router.post("/orchestrate")
-    async def process_task(message: str = Form(...)):
-        response = await master.handle_request(message)
+    async def orchestrate_v2(message: str = Form(...)):
+        """Primary endpoint for all AI logic"""
+        response = await master.process_request(message)
         return {"response": response}
 
-    @router.get("/titan/health")
-    async def health():
-        return await TitanDiagnostics.run_check()
+    @router.get("/status/titan")
+    async def titan_status():
+        report = await master.monitor.run_diagnostics()
+        return {"status": "Titan Active", "report": report}
 
     app.include_router(router)
     app.state.orchestrator = master
 
     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(f"🚀 TITAN ORCHESTRATOR v{master.config.version} DEPLOYED")
+    print(f"✅ Copy-Button Native Support: ACTIVE")
+    print(f"✅ Professional Coding Pipeline: ACTIVE")
+    print(f"✅ User: {username} | Repo: {master.config.repo_name}")
     print("="*60 + "\n")
 
+# =================================================================
+# 7. BOOTSTRAP INITIALIZATION
+# =================================================================
 if __name__ == "__main__":
-    print("Orchestrator testing mode...")
+    print("Titan Orchestrator standalone check...")