nucleus-mcp 1.0.7 → 1.2.0

package/src/mcp_server_nucleus/runtime/storage.py

@@ -1,83 +0,0 @@
-
-import os
-from pathlib import Path
-from typing import Union
-import logging
-
-# Configuration
-STORAGE_TYPE = os.environ.get("NUCLEUS_STORAGE_TYPE", "local")  # local | firestore
-FIRESTORE_COLLECTION = "nucleus_brain"
-
-# Singleton Firestore Client
-_firestore_client = None
-
-
-try:
-    from google.cloud import firestore
-except ImportError:
-    firestore = None
-
-def get_firestore_client():
-    global _firestore_client
-    if _firestore_client is None:
-        if firestore is None:
-            logging.error("google-cloud-firestore not installed.")
-            raise ImportError("google-cloud-firestore module not found")
-        try:
-            _firestore_client = firestore.Client()
-        except Exception as e:
-            logging.error(f"Failed to initialize Firestore: {e}")
-            raise
-    return _firestore_client
-
-def _path_to_id(path: Union[str, Path]) -> str:
-    """Convert a file path to a Firestore Document ID."""
-    # We strip the brain root if possible to make IDs cleaner, 
-    # but for now, just replacing slashes is enough uniqueness.
-    # e.g., "commitments/ledger.json" -> "commitments__ledger.json"
-    p = str(path)
-    # If path is absolute, try to make it relative to brain root?
-    # Actually, simplistic approach: replace / with __
-    return p.strip("/").replace("/", "__").replace(".", "_")
-
-def read_brain_file(path: Union[str, Path]) -> str:
-    """Read a file from Brain (Local or Firestore)."""
-    if STORAGE_TYPE == "firestore":
-        db = get_firestore_client()
-        doc_ref = db.collection(FIRESTORE_COLLECTION).document(_path_to_id(path))
-        doc = doc_ref.get()
-        if doc.exists:
-            return doc.to_dict().get("content", "")
-        else:
-            raise FileNotFoundError(f"Firestore document {doc_ref.id} not found")
-    else:
-        # Local Mode
-        p = Path(path)
-        return p.read_text()
-
-def write_brain_file(path: Union[str, Path], content: str) -> None:
-    """Write content to Brain (Local or Firestore)."""
-    if STORAGE_TYPE == "firestore":
-        db = get_firestore_client()
-        doc_id = _path_to_id(path)
-        doc_ref = db.collection(FIRESTORE_COLLECTION).document(doc_id)
-        
-        doc_ref.set({
-            "content": content,
-            "path": str(path),
-            "updated_at": firestore.SERVER_TIMESTAMP 
-        }, merge=True)
-    else:
-        # Local Mode
-        p = Path(path)
-        p.parent.mkdir(parents=True, exist_ok=True)
-        p.write_text(content)
-
-def brain_file_exists(path: Union[str, Path]) -> bool:
-    """Check if file exists in Brain."""
-    if STORAGE_TYPE == "firestore":
-        db = get_firestore_client()
-        doc_ref = db.collection(FIRESTORE_COLLECTION).document(_path_to_id(path))
-        return doc_ref.get().exists
-    else:
-        return Path(path).exists()

package/src/mcp_server_nucleus/runtime/strategy.py

@@ -1,91 +0,0 @@
-
-import os
-import logging
-from pathlib import Path
-from typing import Dict, Optional
-
-# Configure logger
-logger = logging.getLogger("nucleus.strategy")
-
-def get_brain_path() -> Path:
-    """Get the brain path from environment variable."""
-    brain_path = os.environ.get("NUCLEAR_BRAIN_PATH")
-    if not brain_path:
-        cwd = Path.cwd()
-        if (cwd / ".brain").exists():
-            return cwd / ".brain"
-        for parent in cwd.parents:
-            if (parent / ".brain").exists():
-                return parent / ".brain"
-        raise ValueError("NUCLEAR_BRAIN_PATH environment variable not set")
-    return Path(brain_path)
-
-def _manage_strategy(action: str, content: Optional[str] = None) -> Dict:
-    """
-    Manage the Strategy Document.
-    """
-    try:
-        brain = get_brain_path()
-        strategy_file = brain / "strategy.md"
-        
-        if action == "read":
-            if not strategy_file.exists():
-                return {"status": "empty", "content": ""}
-            return {"status": "success", "content": strategy_file.read_text()}
-            
-        elif action == "update":
-            if not content:
-                return {"error": "Content required for update"}
-            strategy_file.write_text(content)
-            return {"status": "success", "message": "Strategy updated"}
-        
-        elif action == "append":
-             if not content:
-                return {"error": "Content required for append"}
-             current = strategy_file.read_text() if strategy_file.exists() else ""
-             strategy_file.write_text(current + "\n\n" + content)
-             return {"status": "success", "message": "Strategy appended"}
-             
-        else:
-            return {"error": f"Unknown action: {action}"}
-
-    except Exception as e:
-        logger.error(f"Strategy op failed: {e}")
-        return {"error": str(e)}
-
-def _update_roadmap(action: str, item: str = None) -> Dict:
-    """
-    Update the Roadmap.
-    """
-    try:
-        brain = get_brain_path()
-        roadmap_file = brain / "roadmap.md"
-        
-        if action == "read":
-            if not roadmap_file.exists():
-                return {"status": "empty", "content": ""}
-            return {"status": "success", "content": roadmap_file.read_text()}
-            
-        elif action == "add":
-            current = roadmap_file.read_text() if roadmap_file.exists() else "# Roadmap\n"
-            new_content = current + f"\n- [ ] {item}"
-            roadmap_file.write_text(new_content)
-            return {"status": "success", "message": f"Added to roadmap: {item}"}
-            
-        elif action == "complete":
-             if not roadmap_file.exists():
-                 return {"error": "Roadmap not found"}
-             content = roadmap_file.read_text()
-             if item not in content:
-                 return {"error": f"Item not found: {item}"}
-             # Simple string replacement for checkmark
-             new_content = content.replace(f"- [ ] {item}", f"- [x] {item}")
-             roadmap_file.write_text(new_content)
-             return {"status": "success", "message": f"Completed: {item}"}
-
-        else:
-             return {"error": f"Unknown action: {action}. Use 'read', 'add', or 'complete'."}
-             
-    except Exception as e:
-        logger.error(f"Roadmap op failed: {e}")
-        return {"error": str(e)}

package/src/mcp_server_nucleus/runtime/swarm.py

@@ -1,170 +0,0 @@
-"""
-Swarm Orchestration Entry Point.
-Phase 60+ Enterprise Upgrade: Now uses SwarmsOrchestrator for real auto-execution.
-
-This module is the bridge between the MCP tool (brain_orchestrate_swarm)
-and the SwarmsOrchestrator class that handles actual agent spawning.
-"""
-
-import os
-import asyncio
-import logging
-from pathlib import Path
-from typing import Dict, List
-
-# Configure logger
-logger = logging.getLogger("nucleus.swarm")
-
-
-def get_brain_path() -> Path:
-    """Get the brain path from environment variable."""
-    # Try NUCLEUS_BRAIN_PATH first (correct name), then NUCLEAR_BRAIN_PATH (legacy)
-    brain_path = os.environ.get("NUCLEUS_BRAIN_PATH") or os.environ.get("NUCLEAR_BRAIN_PATH")
-    if brain_path and Path(brain_path).exists():
-        return Path(brain_path)
-    
-    # Fallback: search for .brain directory
-    cwd = Path.cwd()
-    if (cwd / ".brain").exists():
-        return cwd / ".brain"
-    for parent in cwd.parents:
-        if (parent / ".brain").exists():
-            return parent / ".brain"
-    
-    # Ultimate fallback
-    return Path("/Users/lokeshgarg/ai-mvp-backend/.brain")
-
-
-def _orchestrate_swarm(mission: str, agents: List[str] = None) -> Dict:
-    """
-    Orchestrate a swarm of agents to complete a complex mission.
-    
-    Phase 60+ UPGRADE: Now uses SwarmsOrchestrator for REAL auto-execution.
-    Agents are spawned automatically in sequence - no manual intervention needed.
-    
-    Args:
-        mission: High-level goal description
-        agents: List of agent personas to recruit (default: ["developer", "critic"])
-        
-    Returns:
-        Dict with mission_id, status, and instructions for checking results
-    """
-    try:
-        from .orchestrator import SwarmsOrchestrator
-        
-        brain_path = get_brain_path()
-        logger.info(f"🐝 Initializing swarm for mission: {mission}")
-        
-        # Create orchestrator
-        orchestrator = SwarmsOrchestrator(brain_path)
-        
-        # Prepare agents list
-        agent_list = agents or ["developer", "critic"]
-        
-        # Apply nest_asyncio for running async in sync context
-        try:
-            import nest_asyncio
-            nest_asyncio.apply()
-        except ImportError:
-            logger.warning("nest_asyncio not available, async may fail in some contexts")
-        
-        # Run the async mission
-        try:
-            # Try to get existing loop
-            loop = asyncio.get_event_loop()
-            if loop.is_running():
-                # We're in an async context, use run_until_complete
-                result = loop.run_until_complete(orchestrator.start_mission(
-                    mission_goal=mission,
-                    swarm_type="execution",
-                    agents=agent_list
-                ))
-            else:
-                # No loop running, use asyncio.run
-                result = asyncio.run(orchestrator.start_mission(
-                    mission_goal=mission,
-                    swarm_type="execution",
-                    agents=agent_list
-                ))
-        except RuntimeError as async_error:
-            # Fallback: create new loop
-            logger.warning(f"Async issue: {async_error}, creating new event loop")
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-            try:
-                result = loop.run_until_complete(orchestrator.start_mission(
-                    mission_goal=mission,
-                    swarm_type="execution",
-                    agents=agent_list
-                ))
-            finally:
-                loop.close()
-        
-        mission_id = result.get("mission_id", "unknown")
-        status = result.get("status", "unknown")
-        
-        logger.info(f"✅ Swarm {mission_id} initiated with agents: {agent_list}")
-        
-        return {
-            "success": True,
-            "mission_id": mission_id,
-            "status": status,
-            "agents": agent_list,
-            "message": f"Swarm {mission_id} started with agents {agent_list}. Agents are executing in background.",
-            "check_results": f".brain/swarms/{mission_id}/summary.md",
-            "check_state": ".brain/swarms/state.json"
-        }
-        
-    except Exception as e:
-        logger.error(f"❌ Swarm orchestration failed: {e}")
-        import traceback
-        traceback.print_exc()
-        return {
-            "success": False,
-            "error": str(e),
-            "message": f"Swarm failed to start: {e}"
-        }
-
-
-def _get_swarm_status(mission_id: str) -> Dict:
-    """
-    Check the status of a running swarm.
-    
-    Args:
-        mission_id: The mission ID returned from _orchestrate_swarm
-        
-    Returns:
-        Current mission state and any artifacts produced
-    """
-    try:
-        from .orchestrator import SwarmsOrchestrator
-        
-        brain_path = get_brain_path()
-        orchestrator = SwarmsOrchestrator(brain_path)
-        
-        # Check state file
-        state = orchestrator._active_missions.get(mission_id)
-        if not state:
-            return {
-                "success": False,
-                "error": f"Mission {mission_id} not found"
-            }
-        
-        # Check for artifacts
-        mission_dir = brain_path / "swarms" / mission_id
-        artifacts = []
-        if mission_dir.exists():
-            for f in mission_dir.iterdir():
-                artifacts.append(str(f.name))
-        
-        return {
-            "success": True,
-            "mission_id": mission_id,
-            "status": state.get("status", "unknown"),
-            "step_count": state.get("step_count", 0),
-            "cost_usd": state.get("cost_usd", 0),
-            "artifacts": artifacts
-        }
-        
-    except Exception as e:
-        return {"success": False, "error": str(e)}