nucleus-mcp 1.0.7 → 1.2.0

package/src/mcp_server_nucleus/runtime/capabilities/render_poller_cap.py

@@ -1,266 +0,0 @@
-from typing import List, Dict, Any, Optional
-import os
-import time
-import asyncio
-import logging
-import urllib.request
-import urllib.error
-import json
-from pathlib import Path
-from .base import Capability
-
-logger = logging.getLogger("nucleus.render_poller")
-
-# Global dict to store active polls in memory
-# {service_id: {"commit_sha": str, "start_time": float, "status": str, "task": asyncio.Task}}
-ACTIVE_POLLS = {}
-
-class RenderPolling(Capability):
-    def __init__(self):
-        self._brain_path = Path(os.environ.get("NUCLEAR_BRAIN_PATH", "/Users/lokeshgarg/.gemini/antigravity/brain/7c654df4-b83e-43f9-8620-f15868ec39d1"))
-        self._api_key = os.environ.get("RENDER_API_KEY")
-        
-    @property
-    def name(self) -> str:
-        return "render_poller"
-
-    @property
-    def description(self) -> str:
-        return "Automated deployment monitoring for Render services."
-
-    def get_tools(self) -> List[Dict[str, Any]]:
-        return [
-            {
-                "name": "brain_start_deploy_poll",
-                "description": "Start monitoring a Render deploy in the background.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "service_id": {"type": "string", "description": "Render service ID (e.g., 'srv-abc123')"},
-                        "commit_sha": {"type": "string", "description": "Optional Git commit SHA being deployed"}
-                    },
-                    "required": ["service_id"]
-                }
-            },
-            {
-                "name": "brain_check_deploy",
-                "description": "Check status of an active deploy poll.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "service_id": {"type": "string", "description": "Render service ID to check"}
-                    },
-                    "required": ["service_id"]
-                }
-            },
-            {
-                "name": "brain_smoke_test",
-                "description": "Run a smoke test on any URL.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "url": {"type": "string", "description": "Base URL of service (e.g., 'https://myapp.onrender.com')"},
-                        "endpoint": {"type": "string", "description": "Health endpoint to hit (default: '/api/health')"}
-                    },
-                    "required": ["url"]
-                }
-            }
-        ]
-
-    def execute_tool(self, tool_name: str, args: Dict) -> Any:
-        try:
-            if tool_name == "brain_start_deploy_poll":
-                return self._start_poll(args.get("service_id"), args.get("commit_sha"))
-            elif tool_name == "brain_check_deploy":
-                return self._check_poll(args.get("service_id"))
-            elif tool_name == "brain_smoke_test":
-                return self._smoke_test(args.get("url"), args.get("endpoint", "/api/health"))
-            return f"Tool {tool_name} not found"
-        except Exception as e:
-            return f"Error executing {tool_name}: {str(e)}"
-
-    def _start_poll(self, service_id: str, commit_sha: Optional[str] = None) -> Dict:
-        """Start a background polling task."""
-        if not service_id:
-            return {"error": "service_id required"}
-
-        # Cancel existing poll for this service
-        if service_id in ACTIVE_POLLS:
-            existing = ACTIVE_POLLS[service_id]
-            if not existing["task"].done():
-                existing["task"].cancel()
-                logger.info(f"Cancelled existing poll for {service_id}")
-
-        # Start new task
-        task = asyncio.create_task(self._poll_loop(service_id, commit_sha))
-        
-        ACTIVE_POLLS[service_id] = {
-            "commit_sha": commit_sha or "latest",
-            "start_time": time.time(),
-            "status": "polling",
-            "task": task,
-            "logs": []
-        }
-        
-        # Log event
-        try:
-            from ... import _emit_event
-            _emit_event("deploy_poll_started", "render_poller", {
-                "service_id": service_id,
-                "commit_sha": commit_sha
-            })
-        except ImportError:
-            pass # Circular import or not available
-
-        return {
-            "success": True, 
-            "message": f"Started polling {service_id}",
-            "poll_id": f"poll_{service_id}_{int(time.time())}"
-        }
-
-    def _check_poll(self, service_id: str) -> Dict:
-        """Check status of an active poll."""
-        if service_id not in ACTIVE_POLLS:
-            return {"status": "not_found", "message": "No active poll for this service."}
-        
-        poll = ACTIVE_POLLS[service_id]
-        uptime = int(time.time() - poll["start_time"])
-        
-        # Check if task is done (failed or finished)
-        if poll["task"].done():
-             try:
-                 result = poll["task"].result()
-                 return {
-                     "status": "complete",
-                     "result": result,
-                     "uptime_seconds": uptime
-                 }
-             except asyncio.CancelledError:
-                 return {"status": "cancelled", "uptime_seconds": uptime}
-             except Exception as e:
-                 return {"status": "error", "error": str(e), "uptime_seconds": uptime}
-        
-        return {
-            "status": "polling",
-            "uptime_seconds": uptime,
-            "commit_sha": poll["commit_sha"]
-        }
-
-    async def _poll_loop(self, service_id: str, commit_sha: Optional[str]):
-        """Async loop to check Render API."""
-        timeout_mins = 20
-        start_time = time.time()
-        
-        if not self._api_key:
-            # Simulation mode if no key
-            await asyncio.sleep(2)
-            if service_id == "srv-test":
-                await asyncio.sleep(1)
-                return {"success": True, "url": "https://test-app.onrender.com", "simulated": True}
-                
-            raise ValueError("RENDER_API_KEY not set")
-
-        headers = {"Authorization": f"Bearer {self._api_key}"}
-        url = f"https://api.render.com/v1/services/{service_id}/deploys?limit=1"
-        req = urllib.request.Request(url, headers=headers)
-        
-        while time.time() - start_time < (timeout_mins * 60):
-            try:
-                loop = asyncio.get_running_loop()
-                # Use run_in_executor for blocking urlopen
-                msg = await loop.run_in_executor(None, lambda: self._fetch_url(req))
-                
-                if "error" in msg:
-                    logger.error(f"Render API error: {msg['error']}")
-                else:
-                    data = msg.get("json", [])
-                    if data:
-                        latest = data[0].get("deploy")
-                        if latest:
-                            status = latest.get("status")
-                            # Match commit if provided
-                            latest_commit = latest.get("commit", {}).get("id")
-                            if commit_sha and latest_commit and not latest_commit.startswith(commit_sha):
-                                # Not our commit yet
-                                pass
-                            elif status == "live":
-                                deploy_url = f"https://{service_id}.onrender.com" # Simplification
-                                
-                                # Run smoke test!
-                                smoke = self._smoke_test(deploy_url)
-                                
-                                # Log complete
-                                try:
-                                    from ... import _emit_event
-                                    _emit_event("deploy_complete", "render_poller", {
-                                        "service_id": service_id,
-                                        "status": "live",
-                                        "url": deploy_url,
-                                        "smoke_test": smoke
-                                    })
-                                except Exception:
-                                    pass
-                                
-                                return {
-                                    "success": True,
-                                    "url": deploy_url,
-                                    "smoke_test": smoke
-                                }
-                            elif status in ["build_failed", "update_failed", "canceled"]:
-                                return {"success": False, "status": status}
-            
-            except Exception as e:
-                logger.error(f"Poll error: {e}")
-
-            await asyncio.sleep(30)
-            
-        return {"success": False, "error": "Timeout"}
-        
-    def _fetch_url(self, req) -> Dict:
-        """Helper to fetch URL synchronously."""
-        try:
-            with urllib.request.urlopen(req, timeout=60) as response:
-                if response.status == 200:
-                    return {"json": json.load(response)}
-                return {"error": f"HTTP {response.status}"}
-        except Exception as e:
-            return {"error": str(e)}
-
-    def _smoke_test(self, url: str, endpoint: str = "/api/health") -> Dict:
-        """Run a smoke test."""
-        try:
-            target = f"{url.rstrip('/')}{endpoint}"
-            start = time.time()
-            
-            req = urllib.request.Request(target)
-            try:
-                with urllib.request.urlopen(req, timeout=60) as response:
-                    latency = (time.time() - start) * 1000
-                    passed = response.status == 200
-                    # Check JSON content if valid
-                    try:
-                        data = json.load(response)
-                        if isinstance(data, dict) and data.get("status") == "healthy":
-                            passed = True
-                    except Exception:
-                        pass
-                    
-                    return {
-                        "passed": passed,
-                        "status_code": response.status,
-                        "latency_ms": latency
-                    }
-            except urllib.error.HTTPError as e:
-                 return {
-                    "passed": False,
-                    "status_code": e.code,
-                    "error": str(e)
-                }
-            except Exception as e:
-                 return {
-                    "passed": False, 
-                    "error": str(e)
-                 }
-
-        except Exception as e:
-            return {"passed": False, "error": str(e)}

package/src/mcp_server_nucleus/runtime/capabilities/self_healing.py

@@ -1,110 +0,0 @@
-
-from typing import List, Dict, Any
-import os
-import subprocess
-from .base import Capability
-
-class SelfHealingOps(Capability):
-    def __init__(self):
-        # Default health command (can be overridden by env)
-        self.health_cmd = os.environ.get("NUCLEUS_HEALTH_CMD", "echo 'No health check configured.'")
-
-    @property
-    def name(self) -> str:
-        return "self_healing_ops"
-
-    @property
-    def description(self) -> str:
-        return "Diagnose and repair codebase issues."
-
-    def get_tools(self) -> List[Dict[str, Any]]:
-        return [
-            {
-                "name": "brain_scan_health",
-                "description": "Run the project's configured health check (tests/lints).",
-                "parameters": {
-                    "type": "object",
-                    "properties": {},
-                    "required": []
-                }
-            },
-            {
-                "name": "brain_generate_fix_plan",
-                "description": "Generate a markdown plan to fix a specific error.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "error_log": {"type": "string", "description": "The error output or log to analyze"},
-                        "context_files": {"type": "array", "items": {"type": "string"}, "description": "List of files related to the error"}
-                    },
-                    "required": ["error_log"]
-                }
-            }
-        ]
-
-    def execute_tool(self, tool_name: str, args: Dict) -> Any:
-        if tool_name == "brain_scan_health":
-            return self._scan_health()
-        elif tool_name == "brain_generate_fix_plan":
-            return self._generate_fix_plan(args)
-        return f"Tool {tool_name} not found"
-
-    def _scan_health(self) -> Dict:
-        """Runs the configured health check command."""
-        try:
-            # Security: We run the command as-is. 
-            # In a real scenario, this should be sandboxed or strictly defined.
-            result = subprocess.run(
-                self.health_cmd,
-                shell=True,
-                capture_output=True,
-                text=True,
-                timeout=120  # 2 minute timeout for health checks
-            )
-            
-            success = result.returncode == 0
-            return {
-                "success": success,
-                "output": result.stdout,
-                "errors": result.stderr,
-                "command": self.health_cmd
-            }
-        except subprocess.TimeoutExpired:
-            return {"success": False, "error": "Health check timed out."}
-        except Exception as e:
-            return {"success": False, "error": str(e)}
-
-    def _generate_fix_plan(self, args: Dict) -> str:
-        """
-        Generates a structured plan for the user (or agent) to execute.
-        This DOES NOT Apply the fix. Safety first.
-        """
-        error_log = args.get("error_log", "")
-        context_files = args.get("context_files", [])
-        
-        # In a full recursive agent, we would use an LLM here to analyze the code.
-        # But since we ARE the LLM (when the tool returns), we return the prompt 
-        # or a structure that helps the calling agent 'think'.
-        
-        # Actually, if this tool is called by an Agent, the Agent expects a result.
-        # Returning a template helps the Agent formulate the next step.
-        
-        return f"""# Fix Plan Generation
-        
-**Analyzed Error:**
-```
-{error_log[:500]}...
-```
-
-**Context Files:**
-{', '.join(context_files)}
-
-**Recommended Strategy:**
-1.  Read the context files using `code_read_file`.
-2.  Analyze the logic causing the error.
-3.  Create a reproduction case if possible.
-4.  Apply the fix using `code_write_file`.
-5.  Re-run `brain_scan_health`.
-
-*System Note: The Agent receiving this output should now proceed to Step 1.*
-"""

package/src/mcp_server_nucleus/runtime/capabilities/strategy.py

@@ -1,138 +0,0 @@
-"""
-Strategy Capability
-Allows the Oracle to interact with the "Cortex" (Strategy Folder).
-"""
-import json
-import logging
-from pathlib import Path
-from typing import Dict, Any, List, Optional
-from ..capabilities.base import Capability
-
-logger = logging.getLogger("cap.strategy")
-
-class StrategyTool(Capability):
-    def __init__(self, brain_path: Path, allowed_paths: List[str]):
-        self.brain_path = brain_path
-        # Resolve variables in paths
-        self.allowed_paths = [
-            Path(p.replace("${BRAIN_PATH}", str(brain_path))).resolve() 
-            for p in allowed_paths
-        ]
-        self._name = "strategy_ops"
-        self._desc = "Read and Evolve Strategic Protocols"
-
-    @property
-    def name(self): return self._name
-
-    @property
-    def description(self): return self._desc
-
-    def get_tools(self) -> List[Dict[str, Any]]:
-        return [
-            {
-                "name": "read_strategy",
-                "description": "Reads a strategy document or protocol.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "filename": {"type": "string", "description": "Relative path to brain root (e.g. 'strategy/SOVEREIGN_TESTAMENT.md')"}
-                    },
-                    "required": ["filename"]
-                }
-            },
-            {
-                "name": "evolve_protocol",
-                "description": "Overwrites/Updates a protocol document with new evolved content.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "filename": {"type": "string"},
-                        "content": {"type": "string", "description": "The new content"},
-                        "reason": {"type": "string", "description": "Why was this evolution necessary?"}
-                    },
-                    "required": ["filename", "content", "reason"]
-                }
-            }
-        ]
-
-    def _validate_path(self, filename: str) -> Optional[Path]:
-        # Simple security verify
-        target = (self.brain_path / filename).resolve()
-        
-        # Check if target is within any allowed path
-        allowed = False
-        for parent in self.allowed_paths:
-            # Check exact match (File allow)
-            if target == parent:
-                allowed = True
-                break
-            # Check directory containment
-            # We assume if it doesn't have an suffix, it might be a dir, 
-            # or we just check if it IS a dir on disk. 
-            # If it's a non-existent dir whitelisted, we can't easily distinguish from file without trailing slash convention.
-            # For now, rely on standard pathlib behavior.
-            try:
-                if parent.is_dir() and str(target).startswith(str(parent)):
-                    allowed = True
-                    break
-            except OSError:
-                pass
-                    
-        if not allowed:
-            logger.warning(f"⛔ ACCESS DENIED: {target} is not in allowed strategy paths.")
-            return None
-            
-        return target
-
-    def execute(self, params: Dict[str, Any]) -> str:
-        # Since I'm binding multiple tools to one capability execute,
-        # I need a way to dispatch. 
-        # But Capability.execute usually takes 'tool_name' or we rely on the implementation wrapping it.
-        # Wait, the Standard we mostly used was: 
-        # 'execute' takes the params of the *tool call*.
-        # But which tool? 
-        # Standard implementation in 'tool_manager' usually passes the Tool Name AND arguments.
-        # But 'Capability.execute' interface in this codebase usually takes just params?
-        # Let's check 'base.py' or 'filesystem.py'.
-        # Assuming for now we need a 'name' or 'action' in params, or we implement separate capabilities.
-        # Let's assume the caller passes the tool name or strict params.
-        
-        # Hack for MVP: Check keys
-        filename = params.get("filename")
-        content = params.get("content")
-        reason = params.get("reason")
-        
-        if content is None:
-            # READ
-            path = self._validate_path(filename)
-            if not path:
-                return "Error: Access Denied"
-            if not path.exists():
-                return "Error: File not found"
-            return path.read_text()
-        else:
-            # WRITE (Evolve)
-            path = self._validate_path(filename)
-            if not path:
-                return "Error: Access Denied"
-            
-            # Log the evolution
-            log_path = self.brain_path / "decisions" / "evolution_log.jsonl"
-            log_path.parent.mkdir(parents=True, exist_ok=True)
-            
-            import datetime
-            entry = {
-                "timestamp": datetime.datetime.now().isoformat(),
-                "file": filename,
-                "reason": reason,
-                "len_delta": len(content) - (path.stat().st_size if path.exists() else 0)
-            }
-            with open(log_path, "a") as f:
-                f.write(json.dumps(entry) + "\n")
-            
-            path.parent.mkdir(parents=True, exist_ok=True)
-            path.write_text(content)
-            return f"Protocol {filename} evolved. Reason: {reason}"
-
-def get_capability(brain_path: Path, config: Dict):
-    return StrategyTool(brain_path, config.get("paths", []))

package/src/mcp_server_nucleus/runtime/capabilities/synthesizer.py

@@ -1,134 +0,0 @@
-"""
-Nucleus Synthesizer
-===================
-The 'Executive Brain' that synthesizes system status into human-readable reports.
-
-Capabilities:
-- brain_synthesize_status_report: Generates a 'State of the Union' roadmap.
-"""
-
-import os
-from pathlib import Path
-from typing import Dict, Optional
-import logging
-import subprocess
-
-try:
-    from google import genai
-    HAS_GENAI = True
-except ImportError:
-    HAS_GENAI = False
-
-logger = logging.getLogger(__name__)
-
-def _get_api_key() -> Optional[str]:
-    return os.environ.get("GEMINI_API_KEY")
-
-def brain_synthesize_status_report(
-    project_root: str,
-    focus: str = "roadmap"
-) -> Dict[str, str]:
-    """
-    Generates a 'State of the Union' report by analyzing tasks, logs, and vision.
-    
-    Args:
-        project_root: Absolute path to project root
-        focus: 'roadmap' (default) or 'technical' or 'marketing'
-        
-    Returns:
-        Dict with status and output report content
-    """
-    if not HAS_GENAI:
-        return {"status": "error", "message": "google-genai library not installed"}
-        
-    api_key = _get_api_key()
-    if not api_key:
-        return {"status": "error", "message": "GEMINI_API_KEY not found"}
-
-    root_path = Path(project_root)
-    
-    # 1. Gather Context
-    context = {}
-    
-    # Task List (What's pending)
-    task_path = root_path / ".brain" / "task.md"
-    if task_path.exists():
-        with open(task_path, 'r') as f:
-            context['tasks'] = f.read()[:5000] # Cap usage
-            
-    # Vision (Where we are going)
-    vision_path = root_path / ".brain" / "NUCLEUS_VISION.md"
-    if vision_path.exists():
-        with open(vision_path, 'r') as f:
-            context['vision'] = f.read()
-
-    # System Status (invisible work)
-    try:
-        cron_output = subprocess.check_output(['crontab', '-l'], stderr=subprocess.STDOUT).decode('utf-8')
-        context['cron'] = cron_output
-    except Exception:
-        context['cron'] = "No crontab accessible."
-        
-    # Logs (Last 20 lines of key logs)
-    log_paths = [
-        root_path / ".brain/ledger/cron.log",
-        Path("/tmp/nucleus_nightly.log"),
-        Path("/tmp/nucleus_orchestrator.log")
-    ]
-    logs_summary = ""
-    for log_p in log_paths:
-        if log_p.exists():
-            try:
-                tail = subprocess.check_output(['tail', '-n', '10', str(log_p)]).decode('utf-8')
-                logs_summary += f"\n--- {log_p.name} ---\n{tail}\n"
-            except Exception:
-                pass
-    context['logs'] = logs_summary
-
-    # 2. Construct Prompt
-    prompt = f"""
-    You are the Nucleus Brain (Executive Function).
-    
-    TASK:
-    Generate a 'State of the Union' report for the Founder (The User).
-    
-    CONTEXT:
-    1. VISION (Where we are going):
-    {context.get('vision', 'No vision file found.')}
-    
-    2. TASKS (What is pending):
-    {context.get('tasks', 'No task file found.')}
-    
-    3. INVISIBLE MACHINERY (What is running in background):
-    CRON: {context.get('cron')}
-    LOGS: {context.get('logs')}
-    
-    INSTRUCTIONS:
-    - Write a clear, high-level Roadmap Report.
-    - Group status into: 
-      1. ✅ Completed Capabilities (The Iron Man Suit)
-      2. ⚙️ Running Machinery (Invisible Work - cite logs)
-      3. 🚧 Active Construction (Next Phase)
-    - Clarify the "Mac vs Cloud" status explicitly.
-    - End with a concrete recommendation for the NEXT move.
-    
-    FORMAT:
-    Markdown. Use Emoji. Be concise.
-    """
-    
-    try:
-        client = genai.Client(api_key=api_key)
-        response = client.models.generate_content(
-            model="gemini-2.0-flash-exp",
-            contents=prompt
-        )
-        
-        report = response.text
-        return {
-            "status": "success",
-            "report": report
-        }
-        
-    except Exception as e:
-        logger.error(f"Status Generation failed: {e}")
-        return {"status": "error", "message": str(e)}