nucleus-mcp 1.0.7 → 1.2.0

package/src/mcp_server_nucleus/runtime/orchestrator.py

@@ -1,370 +0,0 @@
-
-"""
-Preemptive Swarms Orchestrator.
-The "Muscles" of the Nucleus Daemon.
-
-Strategic Role:
-- Manages Agent Swarms (Genesis, Execution).
-- Enforces "Bounded Autonomy" (Budget/Time limits).
-- Bridges the "Context Factory" (Tools) with the "Daemon" (Loop).
-- Future: Triggers "Private Graph Training" (Self-Healing).
-
-Phase 60+ Enterprise Upgrade:
-- REAL agent execution (not mock)
-- Artifact persistence per mission
-- Flywheel logging integration
-"""
-
-import asyncio
-import json
-import logging
-import time
-import re
-from pathlib import Path
-from typing import Dict, Any, Optional, List
-
-from .locking import get_lock
-from .policy import DirectivesLoader, MissionParameters
-from .factory import ContextFactory
-import os
-
-# ============================================================
-# FLYWHEEL LOGGING SETUP (Bug 6 Fix)
-# ============================================================
-def _setup_flywheel_logger():
-    """Configure flywheel.log file handler for all Nucleus components."""
-    try:
-        brain_path = Path(os.environ.get("NUCLEUS_BRAIN_PATH", ".brain"))
-        log_path = brain_path / "flywheel.log"
-        
-        # Create handler
-        handler = logging.FileHandler(log_path, mode='a')
-        handler.setFormatter(logging.Formatter(
-            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-        ))
-        
-        # Add to nucleus logger (and all child loggers)
-        nucleus_logger = logging.getLogger("mcp_server_nucleus")
-        
-        # Avoid duplicate handlers
-        if not any(isinstance(h, logging.FileHandler) for h in nucleus_logger.handlers):
-            nucleus_logger.addHandler(handler)
-            nucleus_logger.setLevel(logging.INFO)
-            
-    except Exception as e:
-        print(f"[Flywheel] Failed to setup logger: {e}")
-
-# Initialize on module load
-_setup_flywheel_logger()
-
-logger = logging.getLogger(__name__)
-
-
-class PrivateGraphTrainer:
-    """
-    Interface for Local Fine-Tuning (Path D: Neural-GPT).
-    Currently a stub, but architecturally placed for Phase 60.
-    """
-    def __init__(self, brain_path: Path):
-        self.brain_path = brain_path
-        
-    async def train_on_session(self, session_id: str, content: str):
-        """
-        Future: Fine-tune local SLM on this session.
-        Current: Log intent.
-        """
-        logger.info(f"🎓 [TRAINER] Would fine-tune on session {session_id}")
-        # Append to training dataset
-        dataset_path = self.brain_path / "training" / "dataset.jsonl"
-        dataset_path.parent.mkdir(parents=True, exist_ok=True)
-        pass
-
-
-class SwarmsOrchestrator:
-    """
-    Enterprise Swarm Orchestrator with REAL agent execution.
-    Bug 4, 6, 7 Fix: No longer a mock - spawns actual EphemeralAgents.
-    """
-    
-    def __init__(self, brain_path: Path):
-        self.brain_path = brain_path
-        self.state_file = brain_path / "swarms" / "state.json"
-        
-        # Dependencies
-        self.policy_engine = DirectivesLoader(brain_path)
-        self.context_factory = ContextFactory(brain_path)
-        self.trainer = PrivateGraphTrainer(brain_path)
-        
-        self._active_missions = {}
-        self._load_state()
-
-    def _load_state(self):
-        """Load swarm state with BrainLock"""
-        if not self.state_file.exists():
-            return
-
-        try:
-            self._active_missions = json.loads(self.state_file.read_text())
-        except Exception as e:
-            logger.error(f"Failed to load swarm state: {e}")
-
-    def _save_state(self):
-        """Save swarm state with BrainLock"""
-        self.state_file.parent.mkdir(parents=True, exist_ok=True)
-        try:
-            with get_lock("swarms", self.brain_path).section():
-                self.state_file.write_text(json.dumps(self._active_missions, indent=2))
-        except Exception as e:
-            logger.error(f"Failed to save swarm state: {e}")
-
-    def _parse_agents_from_goal(self, mission_goal: str) -> List[str]:
-        """
-        Extract agent names from mission goal text.
-        Looks for patterns like: "delegate to 'researcher'" or "Researcher agent"
-        """
-        # Pattern 1: Explicit delegation syntax
-        pattern1 = r"delegate to ['\"]?(\w+)['\"]?"
-        matches = re.findall(pattern1, mission_goal.lower())
-        
-        # Pattern 2: Agent names from known personas
-        known_personas = ["researcher", "critic", "developer", "librarian", "synthesizer", "devops", "architect", "strategist"]
-        for persona in known_personas:
-            if persona in mission_goal.lower():
-                if persona not in matches:
-                    matches.append(persona)
-        
-        # Default if none found
-        if not matches:
-            matches = ["developer"]
-            
-        return matches
-
-    async def start_mission(
-        self, 
-        mission_goal: str, 
-        swarm_type: str = "genesis",
-        agents: List[str] = None
-    ) -> Dict[str, Any]:
-        """
-        Start a new mission with REAL agent execution.
-        
-        Args:
-            mission_goal: High-level goal description
-            swarm_type: "genesis" (planning) or "execution"
-            agents: List of agent personas to spawn (optional)
-        """
-        mission_id = f"mission-{int(time.time())}"
-        logger.info(f"🚀 Starting Mission {mission_id}: {mission_goal}")
-        
-        # Parse agents from goal if not provided
-        if not agents:
-            agents = self._parse_agents_from_goal(mission_goal)
-        
-        logger.info(f"📋 Mission agents: {agents}")
-        
-        # 1. Load Policy constraints
-        params = self.policy_engine.get_mission_parameters(swarm_type)
-        
-        # 2. Initialize Mission State
-        mission_state = {
-            "id": mission_id,
-            "goal": mission_goal,
-            "type": swarm_type,
-            "agents": agents,
-            "status": "running",
-            "step_count": 0,
-            "cost_usd": 0.0,
-            "created_at": time.time(),
-            "max_steps": params.max_steps,
-            "max_budget": params.max_budget_usd,
-            "artifacts": []
-        }
-        
-        self._active_missions[mission_id] = mission_state
-        self._save_state()
-        
-        # 3. Spawn Background Execution via Thread (persists beyond MCP call)
-        import threading
-        
-        def run_mission_in_thread():
-            """Run the async mission loop in a new thread with its own event loop."""
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-            try:
-                loop.run_until_complete(
-                    self._run_mission_loop(mission_id, mission_state, params, agents)
-                )
-            finally:
-                loop.close()
-        
-        thread = threading.Thread(target=run_mission_in_thread, daemon=True)
-        thread.start()
-        logger.info(f"🚀 Mission {mission_id} thread started")
-        
-        return {"mission_id": mission_id, "status": "started"}
-
-
-    async def _run_mission_loop(
-        self, 
-        mission_id: str, 
-        state: Dict, 
-        params: MissionParameters,
-        agents: List[str]
-    ):
-        """
-        The REAL Execution Loop (Bug 4 & 7 Fix).
-        Actually spawns EphemeralAgents and collects their output.
-        """
-        # Lazy imports to avoid circular dependencies
-        from .agent import EphemeralAgent
-        from .llm_client import DualEngineLLM
-        
-        try:
-            logger.info(f"🔄 Mission {mission_id} loop started with agents: {agents}")
-            
-            mission_artifacts = []
-            
-            for i, agent_persona in enumerate(agents):
-                # Check Bounds (Safety First)
-                if state["step_count"] >= params.max_steps:
-                    logger.warning(f"🛑 Mission {mission_id} hit Max Steps ({params.max_steps}). halting.")
-                    state["status"] = "halted_steps"
-                    break
-                    
-                if state["cost_usd"] >= params.max_budget_usd:
-                    logger.warning(f"💸 Mission {mission_id} hit Budget Limit (${params.max_budget_usd}). halting.")
-                    state["status"] = "halted_budget"
-                    break
-                
-                logger.info(f"🤖 Spawning agent {i+1}/{len(agents)}: {agent_persona}")
-                
-                try:
-                    # 1. Create context for this agent
-                    context = self.context_factory.create_context_for_persona(
-                        persona_name=agent_persona,
-                        intent=f"[SWARM {mission_id}] Step {i+1}/{len(agents)}: {state['goal']}",
-                        session_id=mission_id
-                    )
-                    
-                    # QUALITY FIX: Inject absolute project path into context
-                    project_root = str(self.brain_path.parent)
-                    brain_path_str = str(self.brain_path)
-                    
-                    awareness_injection = f"""
-# WORLD AWARENESS
-Current Project Root: {project_root}
-Nucleus Brain Path: {brain_path_str}
-Active Swarm Mission: {mission_id}
-Mission Artifacts: {brain_path_str}/swarms/{mission_id}/
-
-CRITICAL: When using files or tools, always search within the Project Root first.
-"""
-                    context["system_prompt"] = awareness_injection + context["system_prompt"]
-                    
-                    # 2. Get LLM with correct tier routing
-                    # DualEngineLLM takes job_type in constructor and IS the model (has generate_content)
-                    job_type = context.get('job_type', 'ORCHESTRATION')
-                    model = DualEngineLLM(job_type=job_type)
-                    
-                    logger.info(f"📡 Agent {agent_persona} using job_type={job_type}, tier={model.tier}")
-                    
-                    # 3. Spawn and run agent (DualEngineLLM has generate_content method)
-                    agent = EphemeralAgent(context, model)
-                    result = await agent.run()
-                    
-                    # 4. Record results
-                    artifact = {
-                        "agent": agent_persona,
-                        "step": i + 1,
-                        "job_type": job_type,
-                        "result": result[:3000]  # Truncate for storage
-                    }
-                    mission_artifacts.append(artifact)
-                    state["artifacts"].append(artifact)
-                    
-                    logger.info(f"✅ Agent {agent_persona} completed step {i+1}")
-                    
-                except Exception as agent_error:
-                    logger.error(f"💥 Agent {agent_persona} failed: {agent_error}")
-                    mission_artifacts.append({
-                        "agent": agent_persona,
-                        "step": i + 1,
-                        "error": str(agent_error)
-                    })
-                
-                state["step_count"] += 1
-                state["cost_usd"] += 0.05  # Estimated cost per agent
-                
-                # Save checkpoint after each agent
-                self._active_missions[mission_id] = state
-                self._save_state()
-            
-            # 5. Persist artifacts to disk (Bug 4 fix)
-            self._save_mission_artifacts(mission_id, mission_artifacts, state['goal'])
-            
-            # 6. Mark completed
-            if state["status"] == "running":
-                state["status"] = "completed"
-                logger.info(f"✅ Mission {mission_id} Completed with {len(mission_artifacts)} agent outputs.")
-            
-            # 7. Trigger Training (The "Sovereign Loop")
-            await self.trainer.train_on_session(mission_id, json.dumps(mission_artifacts))
-            
-            # Final save
-            self._active_missions[mission_id] = state
-            self._save_state()
-                
-        except Exception as e:
-            logger.error(f"💥 Mission {mission_id} Failed: {e}")
-            state["status"] = "failed"
-            state["error"] = str(e)
-            self._save_state()
-
-    def _save_mission_artifacts(self, mission_id: str, artifacts: List[Dict], goal: str):
-        """
-        Save mission artifacts to .brain/swarms/{mission_id}/summary.md
-        Bug 4 Fix: Ensures artifacts persist to disk.
-        """
-        try:
-            mission_dir = self.brain_path / "swarms" / mission_id
-            mission_dir.mkdir(parents=True, exist_ok=True)
-            
-            # Save summary markdown
-            summary_file = mission_dir / "summary.md"
-            summary_content = f"""# Mission: {mission_id}
-
-**Goal:** {goal}
-**Timestamp:** {time.strftime('%Y-%m-%d %H:%M:%S')}
-**Agents Executed:** {len(artifacts)}
-
----
-
-"""
-            for artifact in artifacts:
-                agent = artifact.get('agent', 'unknown')
-                step = artifact.get('step', 0)
-                result = artifact.get('result', artifact.get('error', 'No output'))
-                job_type = artifact.get('job_type', 'unknown')
-                
-                summary_content += f"""## Step {step}: {agent.title()} ({job_type})
-
-```
-{result}
-```
-
----
-
-"""
-            
-            summary_file.write_text(summary_content)
-            logger.info(f"📄 Saved mission artifacts to {mission_dir}")
-            
-            # Also save raw JSON
-            raw_file = mission_dir / "artifacts.json"
-            raw_file.write_text(json.dumps(artifacts, indent=2))
-            
-        except Exception as e:
-            logger.error(f"Failed to save mission artifacts: {e}")
-            
-    async def get_mission_status(self, mission_id: str) -> Optional[Dict]:
-        return self._active_missions.get(mission_id)

package/src/mcp_server_nucleus/runtime/orchestrator_unified.py

@@ -1,263 +0,0 @@
-"""
-Unified Nucleus Orchestrator (v0.5.0)
-=====================================
-Converges SwarmsOrchestrator (V2) with NucleusOrchestratorV3 (V3).
-
-Single entry point for:
-- Mission/Swarm Management (Ephemeral Agent execution).
-- Task/Queue Management (CRDT Store + Scheduler).
-- System-wide persistence and state synchronization.
-
-Strategic Role:
-- The "Brain" and "Muscles" of the Nucleus Daemon.
-- MDR_010 Compliant: High availability and reliability.
-"""
-
-import json
-import time
-import os
-import logging
-import asyncio
-import threading
-from pathlib import Path
-from typing import Dict, List, Optional
-from datetime import datetime, timezone
-
-# V3 Core Components
-from .crdt_task_store import CRDTTaskStore
-from .task_scheduler import TaskScheduler
-# V2 Logic Components
-from .locking import get_lock
-from .policy import DirectivesLoader, MissionParameters
-from .factory import ContextFactory
-
-logger = logging.getLogger("nucleus.orchestrator")
-
-class UnifiedOrchestrator:
-    """
-    The Single Source of Truth for Nucleus Orchestration.
-    Integrates mission execution with task management.
-    """
-
-    def __init__(self, brain_path: Optional[Path] = None):
-        self.brain_path = brain_path or Path(os.getenv("NUCLEAR_BRAIN_PATH", "/Users/lokeshgarg/ai-mvp-backend/.brain"))
-        self.replica_id = f"nucleus_{int(time.time())}"
-        
-        # 1. Initialize Task Core (V3)
-        self.task_store = CRDTTaskStore(replica_id=self.replica_id)
-        self.scheduler = TaskScheduler(max_agents=1000)
-        
-        # 2. Initialize Mission Logic (V2)
-        self.policy_engine = DirectivesLoader(self.brain_path)
-        self.context_factory = ContextFactory(self.brain_path)
-        
-        # 3. State Management
-        self._active_missions = {}
-        self.swarms_state_file = self.brain_path / "swarms" / "state.json"
-        
-        # Load existing datasets
-        self._load_all_state()
-
-    def _load_all_state(self):
-        """Unified state loader."""
-        # Load Tasks (CRDT logic handles merge)
-        tasks_path = self.brain_path / "ledger" / "tasks.json"
-        if tasks_path.exists():
-            try:
-                with open(tasks_path) as f:
-                    data = json.load(f)
-                
-                # V3.1+ format is {"tasks": [...]}
-                # Older format might be just a list [...]
-                tasks_list = data["tasks"] if isinstance(data, dict) and "tasks" in data else data
-                
-                if not isinstance(tasks_list, list):
-                     tasks_list = []
-                     
-                for task in tasks_list:
-                    self.task_store.add_task(task)
-            except Exception as e:
-                logger.warning(f"Failed to load tasks during unification: {e}")
-
-        # Load Swarms
-        if self.swarms_state_file.exists():
-            try:
-                self._active_missions = json.loads(self.swarms_state_file.read_text())
-            except Exception as e:
-                logger.error(f"Failed to load swarm state: {e}")
-
-    def _save_all_state(self):
-        """Unified state saver."""
-        # Save Tasks
-        tasks_path = self.brain_path / "ledger" / "tasks.json"
-        tasks_path.parent.mkdir(parents=True, exist_ok=True)
-        try:
-            crdt_tasks = self.task_store.get_all_tasks()
-            output = {
-                "tasks": crdt_tasks,
-                "metadata": {
-                    "version": "0.5.0",
-                    "last_synced": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z") if 'timezone' in globals() else time.strftime("%Y-%m-%dT%H:%M:%SZ")
-                }
-            }
-            with open(tasks_path, "w") as f:
-                json.dump(output, f, indent=2)
-        except Exception as e:
-            logger.error(f"Failed to save tasks: {e}")
-
-        # Save Swarms
-        self.swarms_state_file.parent.mkdir(parents=True, exist_ok=True)
-        try:
-            with get_lock("swarms", self.brain_path).section():
-                self.swarms_state_file.write_text(json.dumps(self._active_missions, indent=2))
-        except Exception as e:
-            logger.error(f"Failed to save swarm state: {e}")
-
-    # =========================================================================
-    # TASK OPERATIONS (Brains)
-    # =========================================================================
-
-    def add_task(self, description: str, priority: int = 3, 
-                 tier: str = "T2_CODE", blocked_by: List[str] = None,
-                 source: str = "user", required_skills: List[str] = None) -> Dict:
-        task_id = f"task_{int(time.time() * 1000)}"
-        task = {
-            "id": task_id,
-            "description": description,
-            "status": "PENDING",
-            "tier": tier,
-            "priority": priority,
-            "blocked_by": blocked_by or [],
-            "required_skills": required_skills or [],
-            "source": source,
-            "created_at": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
-            "checkpoint": None,
-            "context_summary": None
-        }
-        self.task_store.add_task(task)
-        self._save_all_state()
-        return {"success": True, "task": task}
-
-    def get_task(self, task_id: str) -> Optional[Dict]:
-        return self.task_store.get_task(task_id)
-
-    def update_task(self, task_id: str, updates: Dict) -> Dict:
-        task = self.task_store.get_task(task_id)
-        if not task:
-            return {"success": False, "error": f"Task {task_id} not found"}
-        for key, value in updates.items():
-            if key != "id":
-                task[key] = value
-        self.task_store.update_task(task_id, task)
-        self._save_all_state()
-        return {"success": True, "task": task}
-
-    def get_next_task(self, skills: List[str] = None) -> Optional[Dict]:
-        tasks = self.task_store.get_all_tasks()
-        available = [t for t in tasks if t.get("status") in ["PENDING", "READY"]]
-        if not available:
-            return None
-        available.sort(key=lambda x: x.get("priority", 3))
-        return available[0]
-
-    # =========================================================================
-    # MISSION OPERATIONS (Muscles)
-    # =========================================================================
-
-    async def start_mission(self, goal: str, swarm_type: str = "genesis", 
-                            agents: List[str] = None) -> Dict:
-        mission_id = f"mission-{int(time.time())}"
-        logger.info(f"🚀 [UNIFIED] Starting Mission {mission_id}")
-        
-        if not agents:
-            agents = self._parse_agents_from_goal(goal)
-            
-        params = self.policy_engine.get_mission_parameters(swarm_type)
-        
-        mission_state = {
-            "id": mission_id,
-            "goal": goal,
-            "type": swarm_type,
-            "agents": agents,
-            "status": "running",
-            "step_count": 0,
-            "created_at": time.time(),
-            "artifacts": []
-        }
-        
-        self._active_missions[mission_id] = mission_state
-        self._save_all_state()
-        
-        # Background execution
-        threading.Thread(target=lambda: self._run_mission_background(mission_id, mission_state, params), daemon=True).start()
-        
-        return {"mission_id": mission_id, "status": "started"}
-
-    def _parse_agents_from_goal(self, goal: str) -> List[str]:
-        known = ["researcher", "critic", "developer", "architect"]
-        matches = [p for p in known if p in goal.lower()]
-        return matches if matches else ["developer"]
-
-    def _run_mission_background(self, mission_id: str, state: Dict, params: MissionParameters):
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-        try:
-            loop.run_until_complete(self._run_mission_loop(mission_id, state, params))
-        except Exception as e:
-            logger.error(f"Mission {mission_id} thread-loop crashed: {e}")
-        finally:
-            loop.close()
-
-    async def _run_mission_loop(self, mission_id: str, state: Dict, params: MissionParameters):
-        from .agent import EphemeralAgent
-        from .llm_client import DualEngineLLM
-        
-        logger.info(f"🔄 [UNIFIED] Loop started for {mission_id}")
-        mission_artifacts = []
-        
-        for i, persona in enumerate(state["agents"]):
-            if state["step_count"] >= params.max_steps:
-                break
-            
-            logger.info(f"🤖 Step {i+1}: Spawning {persona}")
-            context = self.context_factory.create_context_for_persona(
-                persona_name=persona,
-                intent=f"[MISSION {mission_id}] {state['goal']}",
-                session_id=mission_id
-            )
-            
-            model = DualEngineLLM(job_type=context.get('job_type', 'ORCHESTRATION'))
-            agent = EphemeralAgent(context, model)
-            result = await agent.run()
-            
-            artifact = {"agent": persona, "step": i+1, "result": result[:5000]}
-            mission_artifacts.append(artifact)
-            state["artifacts"].append(artifact)
-            state["step_count"] += 1
-            
-            self._save_all_state()
-            
-        self._save_mission_artifacts_to_disk(mission_id, mission_artifacts, state['goal'])
-        state["status"] = "completed"
-        self._save_all_state()
-
-    def _save_mission_artifacts_to_disk(self, mission_id: str, artifacts: List[Dict], goal: str):
-        mission_dir = self.brain_path / "swarms" / mission_id
-        mission_dir.mkdir(parents=True, exist_ok=True)
-        summary = f"# Mission {mission_id}\n\nGoal: {goal}\n\n"
-        for a in artifacts:
-            summary += f"## {a['agent']} (Step {a['step']})\n{a['result']}\n\n---\n\n"
-        (mission_dir / "summary.md").write_text(summary)
-        (mission_dir / "artifacts.json").write_text(json.dumps(artifacts, indent=2))
-
-    def get_mission_status(self, mission_id: str) -> Optional[Dict]:
-        return self._active_missions.get(mission_id)
-
-# Singleton management
-_orchestrator = None
-
-def get_orchestrator() -> UnifiedOrchestrator:
-    global _orchestrator
-    if _orchestrator is None:
-        _orchestrator = UnifiedOrchestrator()
-    return _orchestrator