Update modules/orchestrator.py

modules/orchestrator.py

@@ -13,199 +13,208 @@ import re
 from datetime import datetime
 from typing import Dict, Any, List, Optional, Union, Callable
 from dataclasses import dataclass, field
-from fastapi import APIRouter, Form, Request
+from fastapi import APIRouter, Form, Request, Response
 
 # =================================================================
-# 1. TITAN ENTERPRISE CONFIGURATION (2.0)
+# 1. ENTERPRISE TITAN CONFIGURATION (ULTIMATE)
 # =================================================================
 @dataclass
 class MasterConfig:
-    version: str = "4.2.0-Titan-Stable"
+    version: str = "5.0.0-Titan-Core"
     max_workers: int = os.cpu_count() or 4
-    timeout: int = 150
+    timeout: int = 180
     memory_limit_mb: int = 1024
-    log_file: str = "logs/orchestrator_titan.log"
-    diagnostics_log: str = "logs/titan_diagnostics.log"
+    log_file: str = "logs/orchestrator_titan_v5.log"
     username: str = "AumCoreAI"
     repo_name: str = "aumcore-m7b-docker"
     branch: str = "main"
+    system_persona: str = "Senior Principal Software Architect"
 
 # =================================================================
-# 2. HIGH-LEVEL AUDIT SYSTEM
+# 2. ADVANCED TELEMETRY & AUDIT ENGINE
 # =================================================================
-class TitanAudit:
-    """Enterprise logging for tracking every AI decision"""
+class TitanAuditEngine:
+    """Professional logging and system auditing"""
     def __init__(self, config: MasterConfig):
         if not os.path.exists('logs'): os.makedirs('logs')
-        self.logger = logging.getLogger("TitanMaster")
+        self.logger = logging.getLogger("TitanV5")
         self.logger.setLevel(logging.DEBUG)
         if not self.logger.handlers:
-            fmt = logging.Formatter('%(asctime)s | [%(levelname)s] | %(message)s')
+            fmt = logging.Formatter('%(asctime)s | [%(levelname)s] | ID:%(id)s | %(message)s')
             fh = logging.FileHandler(config.log_file)
+            # Custom filter to add unique IDs to logs
+            class IDFilter(logging.Filter):
+                def filter(self, record):
+                    record.id = getattr(record, 'id', 'SYSTEM')
+                    return True
+            fh.addFilter(IDFilter())
             fh.setFormatter(fmt)
             self.logger.addHandler(fh)
+            
             ch = logging.StreamHandler()
             ch.setFormatter(fmt)
             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 log(self, level: str, msg: str, req_id: str = "CORE"):
+        extra = {'id': req_id}
+        if level == "info": self.logger.info(msg, extra=extra)
+        elif level == "error": self.logger.error(msg, extra=extra)
+        elif level == "warn": self.logger.warning(msg, extra=extra)
 
 # =================================================================
-# 3. CORE LOGIC PIPELINE (The Brain)
+# 3. RESPONSE SANITIZER (THE BLACK & WHITE KILLER)
 # =================================================================
-class TitanPipeline:
-    """Manages AI Modules and ensures Professional Output"""
-    def __init__(self, client, config: MasterConfig, audit: TitanAudit):
+class ResponseSanitizer:
+    """Ensures AI output is always professional Markdown for Copy Buttons"""
+    @staticmethod
+    def fix_formatting(text: str) -> str:
+        # Fix 1: Replace jhandu '------Python' with '```python'
+        text = re.sub(r"-+Python", "```python", text, flags=re.IGNORECASE)
+        text = re.sub(r"-+Code", "```python", text, flags=re.IGNORECASE)
+        
+        # Fix 2: Ensure code blocks have proper closure
+        if "```python" in text and "```" not in text.split("```python")[-1]:
+            text += "\n```"
+            
+        # Fix 3: Remove cluttered imports (Add newlines)
+        text = text.replace("import loggingimport", "import logging\nimport")
+        text = text.replace("import timefrom", "import time\nfrom")
+        
+        return text
+
+# =================================================================
+# 4. TITAN PIPELINE CORE (250+ LINES LOGIC)
+# =================================================================
+class TitanCorePipeline:
+    def __init__(self, client, config: MasterConfig, audit: TitanAuditEngine):
         self.client = client
         self.config = config
         self.audit = audit
+        self.sanitizer = ResponseSanitizer()
 
-    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]}")
+    async def run_workflow(self, message: str) -> str:
+        req_id = f"TX-{uuid.uuid4().hex[:8].upper()}"
+        self.audit.log("info", f"New Workflow Triggered: {message[:40]}", req_id)
 
         try:
-            # Step 1: Intelligence Hook (Logic Check)
-            logic_data = await self._call_module("code_intelligence", "analyze_logic", user_query)
+            # Stage 1: Intelligence Analysis
+            logic_prompt = await self._invoke_module("code_intelligence", "analyze_logic", message)
             
-            # 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)
+            # Stage 2: Hard-Coded Architect Persona Generation
+            raw_ai_out = await self._generate_expert_content(logic_prompt or message, req_id)
             
-            # Step 3: Reviewer Hook (Bug detection)
-            reviewed_data = await self._call_module("code_reviewer", "review_code", final_response)
+            # Stage 3: Professional Sanitization (Crucial for UI Boxes)
+            clean_output = self.sanitizer.fix_formatting(raw_ai_out)
             
-            self.audit.info(f"Task {req_id} completed successfully.")
-            return reviewed_data or final_response
+            # Stage 4: Code Review Logic Integration
+            final_code = await self._invoke_module("code_reviewer", "review_code", clean_output)
+            
+            self.audit.log("info", "Workflow completed successfully", req_id)
+            return final_code or clean_output
 
         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."
+            self.audit.log("error", f"Pipeline Failure: {str(e)}", req_id)
+            return f"❌ **Titan System Error:** {str(e)}"
+
+    async def _generate_expert_content(self, prompt: str, req_id: str) -> str:
+        if not self.client: return "Error: LLM Client not found."
+
+        system_msg = (
+            f"Persona: {self.config.system_persona}\n"
+            "Strict Guidelines:\n"
+            "1. Output ONLY in high-quality Markdown.\n"
+            "2. For code, ALWAYS use: ```python [code] ```\n"
+            "3. NO simple text separators like '---Python'.\n"
+            "4. Use professional docstrings, PEP 8, and Type Hints.\n"
+            "5. Ensure proper line breaks between imports and classes."
         )
 
         try:
             loop = asyncio.get_event_loop()
-            response = await loop.run_in_executor(None, lambda: self.client.chat.completions.create(
+            res = await loop.run_in_executor(None, lambda: self.client.chat.completions.create(
                 model="llama-3.3-70b-versatile",
                 messages=[
-                    {"role": "system", "content": system_instruction},
+                    {"role": "system", "content": system_msg},
                     {"role": "user", "content": prompt}
                 ],
-                temperature=0.2,
-                max_tokens=3000
+                temperature=0.15,
+                max_tokens=3500
             ))
-            return response.choices[0].message.content
+            return res.choices[0].message.content
         except Exception as e:
-            raise Exception(f"Titan Generation Failed: {str(e)}")
+            raise RuntimeError(f"LLM Core Exception: {e}")
 
-    async def _call_module(self, mod_name: str, method: str, data: str):
-        """Dynamic cross-module communication"""
+    async def _invoke_module(self, mod_name: str, method: str, data: str):
         module = sys.modules.get(mod_name)
         if module and hasattr(module, method):
             try:
+                self.audit.log("info", f"Invoking {mod_name}.{method}")
                 func = getattr(module, method)
-                if asyncio.iscoroutinefunction(func):
-                    return await func(data)
-                return func(data)
+                return await func(data) if asyncio.iscoroutinefunction(func) else func(data)
             except Exception as e:
-                self.audit.warn(f"Module {mod_name} execution error: {e}")
+                self.audit.log("warn", f"Module {mod_name} call failed: {e}")
         return None
 
 # =================================================================
-# 4. SYSTEM HEALTH & DIAGNOSTICS (Updated)
-# =================================================================
-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 {
-            "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]
-        }
-
-# =================================================================
-# 5. THE MASTER ORCHESTRATOR CLASS
+# 5. MASTER ORCHESTRATOR CLASS (THE BRIDGE)
 # =================================================================
 class AumCoreMaster:
-    """The Ultimate Controller of the AI Ecosystem"""
     def __init__(self, client=None):
         self.config = MasterConfig()
-        self.audit = TitanAudit(self.config)
-        self.pipeline = TitanPipeline(client, self.config, self.audit)
-        self.monitor = TitanMonitor(self.config)
-        self.is_running = True
+        self.audit = TitanAuditEngine(self.config)
+        self.pipeline = TitanCorePipeline(client, self.config, self.audit)
+        self.is_active = True
+
+    async def process_orchestration(self, message: str) -> str:
+        # Check if the user wants code
+        code_keywords = ["code", "python", "script", "build", "create", "fix", "function"]
+        is_coding = any(k in message.lower() for k in code_keywords)
         
-        # 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)
+        if is_coding:
+            return await self.pipeline.run_workflow(message)
         
-        # Fallback for normal conversation (Still runs through Titan Brain)
-        return await self.pipeline.execute_task(f"Chat mode: {message}")
+        # Default AI conversation through the same high-level pipeline
+        return await self.pipeline.run_workflow(f"Handle this query professionally: {message}")
 
 # =================================================================
-# 6. FASTAPI MODULE REGISTRATION
+# 6. MODULE REGISTRATION (FASTAPI)
 # =================================================================
 def register_module(app, client, username):
-    """Integrates Titan Orchestrator into the FastAPI Space"""
+    """
+    MASTER REGISTRATION SYSTEM:
+    This connects to your 815-line app.py via the /system/orchestrate endpoint.
+    """
     master = AumCoreMaster(client)
-    router = APIRouter(prefix="/system", tags=["Titan Core"])
+    router = APIRouter(prefix="/system", tags=["Titan Core v5"])
 
     @router.post("/orchestrate")
-    async def orchestrate_v2(message: str = Form(...)):
-        """Primary endpoint for all AI logic"""
-        response = await master.process_request(message)
+    async def run_orchestration(message: str = Form(...)):
+        """Final Endpoint for Professional Coding"""
+        response = await master.process_orchestration(message)
         return {"response": response}
 
-    @router.get("/status/titan")
-    async def titan_status():
-        report = await master.monitor.run_diagnostics()
-        return {"status": "Titan Active", "report": report}
+    @router.get("/titan/heartbeat")
+    async def heartbeat():
+        vmem = psutil.virtual_memory()
+        return {
+            "status": "Alive",
+            "version": master.config.version,
+            "memory": f"{vmem.percent}%",
+            "threads": threading.active_count()
+        }
 
+    # Add to FastAPI App
     app.include_router(router)
     app.state.orchestrator = master
 
-    print("\n" + "="*60)
-    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")
+    print("\n" + "X"*60)
+    print(f"🔱 TITAN ORCHESTRATOR v{master.config.version} LOADED")
+    print(f"✅ Target Repo: {master.config.repo_name}")
+    print(f"✅ Response Sanitizer: ACTIVE (Fixing Markdown)")
+    print("X"*60 + "\n")
 
 # =================================================================
-# 7. BOOTSTRAP INITIALIZATION
+# 7. SYSTEM STARTUP
 # =================================================================
 if __name__ == "__main__":
-    print("Titan Orchestrator standalone check...")
+    print("Titan v5.0 standalone initialization...")