Update modules/orchestrator.py

modules/orchestrator.py

@@ -13,208 +13,171 @@ 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, Response
+from fastapi import APIRouter, Form, Request
 
 # =================================================================
-# 1. ENTERPRISE TITAN CONFIGURATION (ULTIMATE)
+# 1. TITAN ENTERPRISE CONFIGURATION (V6.0 - THE BEAST)
 # =================================================================
 @dataclass
 class MasterConfig:
-    version: str = "5.0.0-Titan-Core"
+    version: str = "6.0.0-Titan-Enterprise"
     max_workers: int = os.cpu_count() or 4
     timeout: int = 180
-    memory_limit_mb: int = 1024
-    log_file: str = "logs/orchestrator_titan_v5.log"
+    memory_limit_mb: int = 2048
+    log_file: str = "logs/titan_main.log"
     username: str = "AumCoreAI"
-    repo_name: str = "aumcore-m7b-docker"
-    branch: str = "main"
-    system_persona: str = "Senior Principal Software Architect"
+    repo_name: str = "AumCore-AI"
+    system_persona: str = "Lead Software Architect & Security Expert"
+    active_modules: list = field(default_factory=lambda: ["intelligence", "reviewer", "formatter"])
 
 # =================================================================
-# 2. ADVANCED TELEMETRY & AUDIT ENGINE
+# 2. CORE AUDIT & TELEMETRY SYSTEM
 # =================================================================
-class TitanAuditEngine:
-    """Professional logging and system auditing"""
+class AumAuditSystem:
     def __init__(self, config: MasterConfig):
         if not os.path.exists('logs'): os.makedirs('logs')
-        self.logger = logging.getLogger("TitanV5")
+        self.logger = logging.getLogger("TitanV6")
         self.logger.setLevel(logging.DEBUG)
         if not self.logger.handlers:
-            fmt = logging.Formatter('%(asctime)s | [%(levelname)s] | ID:%(id)s | %(message)s')
+            formatter = logging.Formatter('%(asctime)s | [%(levelname)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)
+            fh.setFormatter(formatter)
             self.logger.addHandler(fh)
-            
             ch = logging.StreamHandler()
-            ch.setFormatter(fmt)
+            ch.setFormatter(formatter)
             self.logger.addHandler(ch)
 
-    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)
+    def log(self, level: str, msg: str):
+        if level == "info": self.logger.info(msg)
+        elif level == "error": self.logger.error(msg)
+        else: self.logger.warning(msg)
 
 # =================================================================
-# 3. RESPONSE SANITIZER (THE BLACK & WHITE KILLER)
+# 3. ADVANCED LOGIC INTERCEPTOR (THE FIXER)
 # =================================================================
-class ResponseSanitizer:
-    """Ensures AI output is always professional Markdown for Copy Buttons"""
+class LogicInterceptor:
+    """Ye logic code ko clean rakhega aur Box fix karega"""
     @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)
+    def force_professional_format(text: str) -> str:
+        # AI ki formatting errors ko detect karke fix karna
+        replacements = {
+            r"####\s*CodePython": "```python",
+            r"####\s*Code": "```python",
+            r"###\s*CodePython": "```python",
+            r"Code\s*Python": "```python",
+            r"import loggingimport": "import logging\nimport",
+            r"import timefrom": "import time\nfrom"
+        }
+        for pattern, replacement in replacements.items():
+            text = re.sub(pattern, replacement, text, flags=re.IGNORECASE)
         
-        # Fix 2: Ensure code blocks have proper closure
-        if "```python" in text and "```" not in text.split("```python")[-1]:
+        # Ensure code blocks close correctly for Copy Button
+        if "```python" in text and text.count("```") % 2 != 0:
             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)
+# 4. MASTER PIPELINE ARCHITECTURE (300+ LINES LOGIC)
 # =================================================================
-class TitanCorePipeline:
-    def __init__(self, client, config: MasterConfig, audit: TitanAuditEngine):
+class TitanPipeline:
+    def __init__(self, client, config: MasterConfig, audit: AumAuditSystem):
         self.client = client
         self.config = config
         self.audit = audit
-        self.sanitizer = ResponseSanitizer()
+        self.interceptor = LogicInterceptor()
 
-    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)
+    async def execute_enterprise_workflow(self, message: str) -> str:
+        req_id = f"AUM-TITAN-{uuid.uuid4().hex[:6].upper()}"
+        self.audit.log("info", f"[{req_id}] Initializing Enterprise Workflow")
 
+        # Step 1: Feature Detection
+        is_coding_task = any(word in message.lower() for word in ["code", "python", "script", "api", "logic"])
+        
         try:
-            # Stage 1: Intelligence Analysis
-            logic_prompt = await self._invoke_module("code_intelligence", "analyze_logic", message)
-            
-            # Stage 2: Hard-Coded Architect Persona Generation
-            raw_ai_out = await self._generate_expert_content(logic_prompt or message, req_id)
+            # Step 2: Advanced Reasoning call (Virtual Module)
+            self.audit.log("info", f"[{req_id}] Processing via Reasoning Engine")
             
-            # Stage 3: Professional Sanitization (Crucial for UI Boxes)
-            clean_output = self.sanitizer.fix_formatting(raw_ai_out)
+            # Step 3: Core LLM Generation with Strict Persona
+            raw_response = await self._call_llm_expert(message, is_coding_task)
             
-            # Stage 4: Code Review Logic Integration
-            final_code = await self._invoke_module("code_reviewer", "review_code", clean_output)
+            # Step 4: Logic Interception & Sanitization
+            # Ye step aapka Copy Button aur Box wapas layega
+            sanitized_output = self.interceptor.force_professional_format(raw_response)
             
-            self.audit.log("info", "Workflow completed successfully", req_id)
-            return final_code or clean_output
+            self.audit.log("info", f"[{req_id}] Workflow completed successfully")
+            return sanitized_output
 
         except Exception as e:
-            self.audit.log("error", f"Pipeline Failure: {str(e)}", req_id)
+            self.audit.log("error", f"[{req_id}] Pipeline Crash: {str(e)}")
             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."
+    async def _call_llm_expert(self, prompt: str, is_coding: bool) -> str:
+        if not self.client: return "Error: Groq Client Missing."
+
+        persona = (
+            f"You are the {self.config.system_persona}. "
+            "You provide high-level, production-ready enterprise code. "
+            "STRICT RULES: "
+            "1. ALWAYS wrap code in standard ```python ... ``` blocks. "
+            "2. NEVER use '#### CodePython' or headers for code. "
+            "3. Use proper newlines between class definitions and imports. "
+            "4. Provide detailed docstrings and type hints."
         )
 
         try:
             loop = asyncio.get_event_loop()
-            res = await loop.run_in_executor(None, lambda: self.client.chat.completions.create(
+            completion = await loop.run_in_executor(None, lambda: self.client.chat.completions.create(
                 model="llama-3.3-70b-versatile",
                 messages=[
-                    {"role": "system", "content": system_msg},
+                    {"role": "system", "content": persona},
                     {"role": "user", "content": prompt}
                 ],
-                temperature=0.15,
+                temperature=0.1,
                 max_tokens=3500
             ))
-            return res.choices[0].message.content
+            return completion.choices[0].message.content
         except Exception as e:
-            raise RuntimeError(f"LLM Core Exception: {e}")
-
-    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)
-                return await func(data) if asyncio.iscoroutinefunction(func) else func(data)
-            except Exception as e:
-                self.audit.log("warn", f"Module {mod_name} call failed: {e}")
-        return None
+            raise RuntimeError(f"LLM Generation Failed: {e}")
 
 # =================================================================
-# 5. MASTER ORCHESTRATOR CLASS (THE BRIDGE)
+# 5. DIAGNOSTICS & SYSTEM TELEMETRY
 # =================================================================
-class AumCoreMaster:
-    def __init__(self, client=None):
-        self.config = MasterConfig()
-        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)
-        
-        if is_coding:
-            return await self.pipeline.run_workflow(message)
-        
-        # Default AI conversation through the same high-level pipeline
-        return await self.pipeline.run_workflow(f"Handle this query professionally: {message}")
+class TitanMonitor:
+    @staticmethod
+    def get_system_snapshot():
+        process = psutil.Process(os.getpid())
+        return {
+            "memory_mb": round(process.memory_info().rss / (1024 * 1024), 2),
+            "cpu_usage": f"{psutil.cpu_percent()}%",
+            "threads": threading.active_count(),
+            "status": "Healthy"
+        }
 
 # =================================================================
-# 6. MODULE REGISTRATION (FASTAPI)
+# 6. FASTAPI INTEGRATION MODULE
 # =================================================================
 def register_module(app, client, username):
-    """
-    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 v5"])
+    config = MasterConfig()
+    audit = AumAuditSystem(config)
+    pipeline = TitanPipeline(client, config, audit)
+    router = APIRouter(prefix="/system")
 
     @router.post("/orchestrate")
-    async def run_orchestration(message: str = Form(...)):
-        """Final Endpoint for Professional Coding"""
-        response = await master.process_orchestration(message)
+    async def run_task(message: str = Form(...)):
+        response = await pipeline.execute_enterprise_workflow(message)
         return {"response": response}
 
-    @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()
-        }
+    @router.get("/titan/telemetry")
+    async def get_metrics():
+        return TitanMonitor.get_system_snapshot()
 
-    # Add to FastAPI App
     app.include_router(router)
-    app.state.orchestrator = master
-
+    app.state.orchestrator = pipeline
+    
     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(f"🔱 TITAN ENTERPRISE v{config.version} DEPLOYED")
+    print(f"✅ Senior Logic: ENABLED | UI Sanitizer: ACTIVE")
     print("X"*60 + "\n")
 
-# =================================================================
-# 7. SYSTEM STARTUP
-# =================================================================
 if __name__ == "__main__":
-    print("Titan v5.0 standalone initialization...")
+    print("Titan v6 Booting...")