nucleus-mcp 1.0.7 → 1.2.0

package/src/mcp_server_nucleus/runtime/plugin_loader.py

@@ -1,84 +0,0 @@
-"""
-PluginLoader v2: The Airlock.
-Strictly controls how tools enter the Nucleus Runtime.
-
-Strategic Role:
-- Enforces "Air Gap": Only loads tools explicitly allowed by Manifest.
-- Enforces "Governance": Wraps all tools in BudgetGuard.
-- Isolates Agents: Scopes loading to specific Agent Directory.
-"""
-
-import sys
-import importlib.util
-import logging
-from pathlib import Path
-from typing import List
-from .capabilities.base import Capability
-from .budget import BudgetAuditor, BudgetGuard
-
-logger = logging.getLogger("nucleus.plugins")
-
-class PluginLoader:
-    def __init__(self, brain_path: Path, auditor: BudgetAuditor):
-        self.brain_path = brain_path
-        self.auditor = auditor
-        self.installed_tools_dir = brain_path / "tools" / "installed"
-
-    def load_agent_tools(self, agent_id: str, authorized_modules: List[str]) -> List[Capability]:
-        """
-        Loads allowed tools for a specific agent.
-        Wraps them in BudgetGuard(default=$0.00).
-        """
-        agent_dir = self.installed_tools_dir / agent_id
-        
-        if not agent_dir.exists():
-            logger.warning(f"⚠️ Agent directory not found: {agent_dir}")
-            return []
-            
-        logger.info(f"🔌 Accessing Agent Airlock: {agent_id}")
-        
-        # Ensure the directory is in python path
-        sys.path.append(str(agent_dir))
-        
-        loaded_plugins = []
-        
-        for module_name in authorized_modules:
-            # Construct expected file path
-            tool_path = agent_dir / f"{module_name}.py"
-            
-            if not tool_path.exists():
-                logger.error(f"❌ Missing authorized tool: {module_name} in {agent_dir}")
-                continue
-                
-            try:
-                # Import Module
-                spec = importlib.util.spec_from_file_location(module_name, tool_path)
-                if spec and spec.loader:
-                    module = importlib.util.module_from_spec(spec)
-                    spec.loader.exec_module(module)
-                    
-                    if hasattr(module, "get_capability"):
-                        cap = module.get_capability()
-                        if isinstance(cap, Capability):
-                            
-                            # --- GOVERNANCE WRAPPER ---
-                            # By default, tools have $0.00 budget until Policy grants more.
-                            # We wrap immediately to ensure safety.
-                            guarded_cap = BudgetGuard(
-                                inner=cap,
-                                auditor=self.auditor,
-                                agent_id=agent_id,
-                                max_budget_usd=0.0 # Default Deny
-                            )
-                            
-                            loaded_plugins.append(guarded_cap)
-                            logger.info(f"    ✅ Loaded & Secured: {cap.name}")
-                        else:
-                            logger.warning(f"    ⚠️ Invalid Capability in {module_name}")
-                    else:
-                        logger.warning(f"    ℹ️ Missing entry point in {module_name}")
-                        
-            except Exception as e:
-                logger.error(f"    ❌ Failed to load {module_name}: {e}")
-                
-        return loaded_plugins

package/src/mcp_server_nucleus/runtime/policy.py

@@ -1,117 +0,0 @@
-
-"""
-Policy Engine for Nucleus Daemon.
-Handles 'Adaptive Policy' (Directives) and 'Bounded Autonomy' (Mission Parameters).
-
-Strategic Role:
-- Reads `directives.md` to align Daemon with user intent.
-- Enforces `MissionParameters` (Budget, Time, Safety) to prevent "Strategic Drift".
-- Provides the `SafetyLevel` context for "Unshackled" operations.
-"""
-
-from enum import Enum
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import List, Dict
-import json 
-import logging
-
-logger = logging.getLogger(__name__)
-
-class SafetyLevel(Enum):
-    SAFE = "safe"           # Standard SaaS-like filters
-    MODERATE = "moderate"   # Less restrictive, warns on high risk
-    RAW = "raw"             # "Unshackled" - No middleware constraints (User liability)
-
-class ExecutionMode(Enum):
-    PLANNING = "planning"
-    EXECUTION = "execution"
-    VERIFICATION = "verification"
-
-@dataclass
-class MissionParameters:
-    """The Compact: Bounded Autonomy Agreement"""
-    max_budget_usd: float = 1.0
-    max_steps: int = 10
-    timeout_seconds: int = 600
-    allowed_tools: List[str] = field(default_factory=list)
-    blocked_tools: List[str] = field(default_factory=list)
-    safety_level: SafetyLevel = SafetyLevel.SAFE
-    # If true, requires explicit human ratification before "Write" actions
-    require_ratification: bool = False
-
-class DirectivesLoader:
-    def __init__(self, brain_path: Path):
-        self.brain_path = brain_path
-        self.directives_path = brain_path / "ledger" / "directives.md"
-        # Support json config as alternative
-        self.config_path = brain_path / "ledger" / "policy.json"
-
-    def load_policy(self) -> Dict:
-        """Load the current policy directives"""
-        policy = {
-            "mode": "default",
-            "priorities": [],
-            "constraints": [],
-            "safety_level": SafetyLevel.SAFE.value
-        }
-        
-        # 1. Try Config JSON first (Structured)
-        if self.config_path.exists():
-            try:
-                with open(self.config_path, 'r') as f:
-                    data = json.load(f)
-                    if data:
-                        policy.update(data)
-            except Exception as e:
-                logger.error(f"Failed to load policy.json: {e}")
-
-        # 2. Parse Markdown Directives (Context)
-        # For now, we just verify it exists to be available for LLM context injection
-        # In Phase 60, we might NLP parse strict rules from MD.
-        policy["directives_text"] = self._read_directives_text()
-        
-        return policy
-
-    def _read_directives_text(self) -> str:
-        if self.directives_path.exists():
-            return self.directives_path.read_text()
-        return "No directives found. Operate in default safe mode."
-
-    def get_mission_parameters(self, task_type: str) -> MissionParameters:
-        """Factory for Mission Parameters based on Task Type"""
-        policy = self.load_policy()
-        safety_val = policy.get("safety_level", "safe")
-        
-        try:
-            safety = SafetyLevel(safety_val)
-        except ValueError:
-            safety = SafetyLevel.SAFE
-
-        # Default Profiles
-        if task_type == "quick_check":
-            return MissionParameters(
-                max_budget_usd=0.05,
-                max_steps=5,
-                timeout_seconds=60,
-                safety_level=safety
-            )
-        elif task_type == "deep_research":
-            return MissionParameters(
-                max_budget_usd=2.0,
-                max_steps=30,
-                timeout_seconds=1800,
-                safety_level=safety,
-                blocked_tools=["write_to_file", "run_command"] # Read only
-            )
-        elif task_type == "autonomous_fix":
-            return MissionParameters(
-                max_budget_usd=0.5,
-                max_steps=15,
-                timeout_seconds=300,
-                safety_level=safety,
-                require_ratification=True # Fixes usually need approval in V1
-            )
-        
-        # Default
-        return MissionParameters(safety_level=safety)

package/src/mcp_server_nucleus/runtime/profiling.py

@@ -1,219 +0,0 @@
-"""
-Nucleus Runtime - Performance Profiling (AG-014)
-=================================================
-Timing decorators and performance monitoring for identifying bottlenecks.
-
-Usage:
-    from .profiling import timed, get_metrics, reset_metrics
-
-    @timed("task_list")
-    def _list_tasks(...):
-        ...
-
-    # Get metrics
-    metrics = get_metrics()
-    print(metrics["task_list"])  # {"calls": 10, "total_ms": 150.5, "avg_ms": 15.05}
-"""
-
-import time
-import functools
-import threading
-from typing import Dict, Any, Callable, Optional
-from datetime import datetime, timezone
-import json
-import os
-from pathlib import Path
-
-# Thread-safe metrics storage
-_metrics_lock = threading.Lock()
-_metrics: Dict[str, Dict[str, Any]] = {}
-
-# Configuration
-PROFILING_ENABLED = os.environ.get("NUCLEUS_PROFILING", "false").lower() == "true"
-SLOW_THRESHOLD_MS = float(os.environ.get("NUCLEUS_SLOW_THRESHOLD_MS", "100"))
-
-
-def timed(operation_name: str, log_slow: bool = True):
-    """
-    Decorator to time function execution and collect metrics.
-    
-    Args:
-        operation_name: Name for this operation in metrics
-        log_slow: Whether to log warning for slow operations
-    
-    Example:
-        @timed("brain_list_tasks")
-        def _list_tasks():
-            ...
-    """
-    def decorator(func: Callable) -> Callable:
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            if not PROFILING_ENABLED:
-                return func(*args, **kwargs)
-            
-            start = time.perf_counter()
-            try:
-                result = func(*args, **kwargs)
-                return result
-            finally:
-                elapsed_ms = (time.perf_counter() - start) * 1000
-                _record_metric(operation_name, elapsed_ms, log_slow)
-        
-        @functools.wraps(func)
-        async def async_wrapper(*args, **kwargs):
-            if not PROFILING_ENABLED:
-                return await func(*args, **kwargs)
-            
-            start = time.perf_counter()
-            try:
-                result = await func(*args, **kwargs)
-                return result
-            finally:
-                elapsed_ms = (time.perf_counter() - start) * 1000
-                _record_metric(operation_name, elapsed_ms, log_slow)
-        
-        # Return appropriate wrapper based on function type
-        if asyncio_iscoroutinefunction(func):
-            return async_wrapper
-        return wrapper
-    return decorator
-
-
-def asyncio_iscoroutinefunction(func):
-    """Check if function is async."""
-    import inspect
-    return inspect.iscoroutinefunction(func)
-
-
-def _record_metric(operation_name: str, elapsed_ms: float, log_slow: bool):
-    """Record a timing metric (thread-safe)."""
-    with _metrics_lock:
-        if operation_name not in _metrics:
-            _metrics[operation_name] = {
-                "calls": 0,
-                "total_ms": 0.0,
-                "min_ms": float('inf'),
-                "max_ms": 0.0,
-                "last_call": None,
-                "slow_count": 0
-            }
-        
-        m = _metrics[operation_name]
-        m["calls"] += 1
-        m["total_ms"] += elapsed_ms
-        m["min_ms"] = min(m["min_ms"], elapsed_ms)
-        m["max_ms"] = max(m["max_ms"], elapsed_ms)
-        m["last_call"] = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
-        
-        if elapsed_ms > SLOW_THRESHOLD_MS:
-            m["slow_count"] += 1
-            if log_slow:
-                # Use print for now, can integrate with structured logging
-                print(f"⚠️ SLOW: {operation_name} took {elapsed_ms:.2f}ms (threshold: {SLOW_THRESHOLD_MS}ms)")
-
-
-def get_metrics() -> Dict[str, Dict[str, Any]]:
-    """
-    Get current performance metrics.
-    
-    Returns:
-        Dict with metrics per operation:
-        {
-            "operation_name": {
-                "calls": int,
-                "total_ms": float,
-                "avg_ms": float,
-                "min_ms": float,
-                "max_ms": float,
-                "slow_count": int,
-                "last_call": str (ISO timestamp)
-            }
-        }
-    """
-    with _metrics_lock:
-        result = {}
-        for name, m in _metrics.items():
-            result[name] = {
-                **m,
-                "avg_ms": m["total_ms"] / m["calls"] if m["calls"] > 0 else 0
-            }
-            # Clean up inf for JSON serialization
-            if result[name]["min_ms"] == float('inf'):
-                result[name]["min_ms"] = 0
-        return result
-
-
-def reset_metrics():
-    """Reset all metrics (useful for testing)."""
-    global _metrics
-    with _metrics_lock:
-        _metrics = {}
-
-
-def get_metrics_summary() -> str:
-    """Get a formatted summary of metrics."""
-    metrics = get_metrics()
-    if not metrics:
-        return "No metrics collected. Set NUCLEUS_PROFILING=true to enable."
-    
-    lines = ["# Performance Metrics", ""]
-    lines.append("| Operation | Calls | Avg (ms) | Min | Max | Slow |")
-    lines.append("|-----------|-------|----------|-----|-----|------|")
-    
-    for name, m in sorted(metrics.items(), key=lambda x: -x[1]["total_ms"]):
-        lines.append(
-            f"| {name} | {m['calls']} | {m['avg_ms']:.2f} | "
-            f"{m['min_ms']:.2f} | {m['max_ms']:.2f} | {m['slow_count']} |"
-        )
-    
-    lines.append("")
-    lines.append(f"*Slow threshold: {SLOW_THRESHOLD_MS}ms*")
-    return "\n".join(lines)
-
-
-def export_metrics_to_file(brain_path: Optional[Path] = None) -> str:
-    """
-    Export metrics to a JSON file in the brain folder.
-    
-    Args:
-        brain_path: Path to brain folder (uses env var if not provided)
-    
-    Returns:
-        Path to exported file
-    """
-    if brain_path is None:
-        brain_path = Path(os.environ.get("NUCLEAR_BRAIN_PATH", ".brain"))
-    
-    metrics_dir = brain_path / "metrics"
-    metrics_dir.mkdir(parents=True, exist_ok=True)
-    
-    timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
-    filepath = metrics_dir / f"perf_{timestamp}.json"
-    
-    data = {
-        "exported_at": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
-        "threshold_ms": SLOW_THRESHOLD_MS,
-        "metrics": get_metrics()
-    }
-    
-    with open(filepath, 'w') as f:
-        json.dump(data, f, indent=2)
-    
-    return str(filepath)
-
-
-# Convenience decorators for common operations
-def timed_io(func):
-    """Decorator for I/O-bound operations (file reads, etc.)."""
-    return timed(f"io.{func.__name__}", log_slow=True)(func)
-
-
-def timed_compute(func):
-    """Decorator for compute-bound operations."""
-    return timed(f"compute.{func.__name__}", log_slow=True)(func)
-
-
-def timed_llm(func):
-    """Decorator for LLM API calls (expected to be slow)."""
-    return timed(f"llm.{func.__name__}", log_slow=False)(func)