nucleus-mcp 1.0.7 → 1.2.0

package/src/mcp_server_nucleus/runtime/prometheus.py

@@ -1,286 +0,0 @@
-"""
-Nucleus Runtime - Prometheus Metrics (AG-015)
-==============================================
-Prometheus-compatible metrics endpoint for monitoring Nucleus.
-
-Usage:
-    # In your monitoring setup, scrape:
-    # GET /metrics (if HTTP server enabled)
-    # OR call brain_prometheus_metrics() MCP tool
-
-    # Metrics exported:
-    # - nucleus_tool_calls_total{tool="brain_health"} 
-    # - nucleus_tool_errors_total{tool="brain_health"}
-    # - nucleus_tool_latency_seconds{tool="brain_health",quantile="0.5"}
-    # - nucleus_tasks_total{status="PENDING"}
-    # - nucleus_sessions_total
-    # - nucleus_events_total
-"""
-
-import time
-import threading
-from typing import Dict, Any, List
-from datetime import datetime, timezone
-from collections import defaultdict
-import os
-import json
-from pathlib import Path
-
-# Thread-safe metrics storage
-_metrics_lock = threading.Lock()
-
-# Counters
-_tool_calls: Dict[str, int] = defaultdict(int)
-_tool_errors: Dict[str, int] = defaultdict(int)
-
-# Histograms (simplified - store recent latencies)
-_tool_latencies: Dict[str, List[float]] = defaultdict(list)
-MAX_LATENCY_SAMPLES = 1000  # Keep last N samples per tool
-
-# Gauges (current values)
-_gauges: Dict[str, float] = {}
-
-# Configuration
-METRICS_ENABLED = os.environ.get("NUCLEUS_METRICS", "true").lower() == "true"
-
-
-def inc_counter(name: str, labels: Dict[str, str] = None, value: int = 1):
-    """Increment a counter metric."""
-    if not METRICS_ENABLED:
-        return
-    
-    key = _make_key(name, labels)
-    with _metrics_lock:
-        if name.endswith("_errors"):
-            _tool_errors[key] += value
-        else:
-            _tool_calls[key] += value
-
-
-def observe_latency(tool_name: str, latency_seconds: float):
-    """Record a latency observation for a tool."""
-    if not METRICS_ENABLED:
-        return
-    
-    with _metrics_lock:
-        latencies = _tool_latencies[tool_name]
-        latencies.append(latency_seconds)
-        # Keep bounded
-        if len(latencies) > MAX_LATENCY_SAMPLES:
-            _tool_latencies[tool_name] = latencies[-MAX_LATENCY_SAMPLES:]
-
-
-def set_gauge(name: str, value: float, labels: Dict[str, str] = None):
-    """Set a gauge metric to a specific value."""
-    if not METRICS_ENABLED:
-        return
-    
-    key = _make_key(name, labels)
-    with _metrics_lock:
-        _gauges[key] = value
-
-
-def _make_key(name: str, labels: Dict[str, str] = None) -> str:
-    """Create a metric key from name and labels."""
-    if not labels:
-        return name
-    label_str = ",".join(f'{k}="{v}"' for k, v in sorted(labels.items()))
-    return f"{name}{{{label_str}}}"
-
-
-def _calculate_quantiles(values: List[float], quantiles: List[float] = [0.5, 0.9, 0.99]) -> Dict[str, float]:
-    """Calculate quantiles from a list of values."""
-    if not values:
-        return {str(q): 0.0 for q in quantiles}
-    
-    sorted_values = sorted(values)
-    n = len(sorted_values)
-    result = {}
-    
-    for q in quantiles:
-        idx = int(q * n)
-        if idx >= n:
-            idx = n - 1
-        result[str(q)] = sorted_values[idx]
-    
-    return result
-
-
-def get_prometheus_metrics() -> str:
-    """
-    Generate Prometheus text format metrics.
-    
-    Returns:
-        Prometheus exposition format string
-    """
-    lines = []
-    
-    # Header
-    lines.append("# Nucleus MCP Server Metrics")
-    lines.append(f"# Generated at {datetime.now(timezone.utc).isoformat()}")
-    lines.append("")
-    
-    with _metrics_lock:
-        # Tool call counters
-        lines.append("# HELP nucleus_tool_calls_total Total number of tool calls")
-        lines.append("# TYPE nucleus_tool_calls_total counter")
-        for key, value in _tool_calls.items():
-            lines.append(f"nucleus_tool_calls_total{{{_extract_labels(key)}}} {value}")
-        
-        # Tool error counters
-        lines.append("")
-        lines.append("# HELP nucleus_tool_errors_total Total number of tool errors")
-        lines.append("# TYPE nucleus_tool_errors_total counter")
-        for key, value in _tool_errors.items():
-            lines.append(f"nucleus_tool_errors_total{{{_extract_labels(key)}}} {value}")
-        
-        # Latency histograms (as summary with quantiles)
-        lines.append("")
-        lines.append("# HELP nucleus_tool_latency_seconds Tool execution latency")
-        lines.append("# TYPE nucleus_tool_latency_seconds summary")
-        for tool_name, latencies in _tool_latencies.items():
-            if latencies:
-                quantiles = _calculate_quantiles(latencies)
-                for q, v in quantiles.items():
-                    lines.append(f'nucleus_tool_latency_seconds{{tool="{tool_name}",quantile="{q}"}} {v:.6f}')
-                lines.append(f'nucleus_tool_latency_seconds_sum{{tool="{tool_name}"}} {sum(latencies):.6f}')
-                lines.append(f'nucleus_tool_latency_seconds_count{{tool="{tool_name}"}} {len(latencies)}')
-        
-        # Gauges
-        lines.append("")
-        lines.append("# HELP nucleus_gauge Current gauge values")
-        lines.append("# TYPE nucleus_gauge gauge")
-        for key, value in _gauges.items():
-            lines.append(f"nucleus_gauge{{{_extract_labels(key)}}} {value}")
-    
-    # Add brain state metrics if available
-    try:
-        brain_path = Path(os.environ.get("NUCLEAR_BRAIN_PATH", ".brain"))
-        
-        # Task counts by status
-        tasks_file = brain_path / "ledger" / "tasks.json"
-        if tasks_file.exists():
-            tasks = json.loads(tasks_file.read_text())
-            status_counts = defaultdict(int)
-            for task in tasks:
-                status_counts[task.get("status", "UNKNOWN")] += 1
-            
-            lines.append("")
-            lines.append("# HELP nucleus_tasks_total Number of tasks by status")
-            lines.append("# TYPE nucleus_tasks_total gauge")
-            for status, count in status_counts.items():
-                lines.append(f'nucleus_tasks_total{{status="{status}"}} {count}')
-        
-        # Session count
-        sessions_dir = brain_path / "sessions"
-        if sessions_dir.exists():
-            session_count = len(list(sessions_dir.glob("*.json")))
-            lines.append("")
-            lines.append("# HELP nucleus_sessions_total Total saved sessions")
-            lines.append("# TYPE nucleus_sessions_total gauge")
-            lines.append(f"nucleus_sessions_total {session_count}")
-        
-        # Event count
-        events_file = brain_path / "ledger" / "events.jsonl"
-        if events_file.exists():
-            with open(events_file) as f:
-                event_count = sum(1 for _ in f)
-            lines.append("")
-            lines.append("# HELP nucleus_events_total Total events logged")
-            lines.append("# TYPE nucleus_events_total gauge")
-            lines.append(f"nucleus_events_total {event_count}")
-            
-    except Exception:
-        pass  # Silently skip brain metrics if unavailable
-    
-    lines.append("")
-    return "\n".join(lines)
-
-
-def _extract_labels(key: str) -> str:
-    """Extract labels from a metric key."""
-    if "{" in key:
-        start = key.index("{")
-        end = key.rindex("}")
-        return key[start+1:end]
-    return f'name="{key}"'
-
-
-def reset_metrics():
-    """Reset all metrics (useful for testing)."""
-    global _tool_calls, _tool_errors, _tool_latencies, _gauges
-    with _metrics_lock:
-        _tool_calls = defaultdict(int)
-        _tool_errors = defaultdict(int)
-        _tool_latencies = defaultdict(list)
-        _gauges = {}
-
-
-def get_metrics_json() -> Dict[str, Any]:
-    """Get metrics as JSON (alternative to Prometheus format)."""
-    with _metrics_lock:
-        latency_stats = {}
-        for tool_name, latencies in _tool_latencies.items():
-            if latencies:
-                latency_stats[tool_name] = {
-                    "count": len(latencies),
-                    "sum": sum(latencies),
-                    "avg": sum(latencies) / len(latencies),
-                    "quantiles": _calculate_quantiles(latencies)
-                }
-        
-        return {
-            "tool_calls": dict(_tool_calls),
-            "tool_errors": dict(_tool_errors),
-            "latencies": latency_stats,
-            "gauges": dict(_gauges),
-            "timestamp": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
-        }
-
-
-# Decorator for automatic metrics collection
-def metrics_tracked(tool_name: str):
-    """
-    Decorator to automatically track tool metrics.
-    
-    Usage:
-        @metrics_tracked("brain_health")
-        def brain_health():
-            ...
-    """
-    def decorator(func):
-        import functools
-        
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            start = time.perf_counter()
-            try:
-                result = func(*args, **kwargs)
-                inc_counter("tool_calls", {"tool": tool_name})
-                return result
-            except Exception:
-                inc_counter("tool_errors", {"tool": tool_name})
-                raise
-            finally:
-                latency = time.perf_counter() - start
-                observe_latency(tool_name, latency)
-        
-        @functools.wraps(func)
-        async def async_wrapper(*args, **kwargs):
-            start = time.perf_counter()
-            try:
-                result = await func(*args, **kwargs)
-                inc_counter("tool_calls", {"tool": tool_name})
-                return result
-            except Exception:
-                inc_counter("tool_errors", {"tool": tool_name})
-                raise
-            finally:
-                latency = time.perf_counter() - start
-                observe_latency(tool_name, latency)
-        
-        import inspect
-        if inspect.iscoroutinefunction(func):
-            return async_wrapper
-        return wrapper
-    return decorator

package/src/mcp_server_nucleus/runtime/proposals.py

@@ -1,101 +0,0 @@
-
-"""
-ProposalOps: Deep Thought & Ratification Engine.
-Allows the Daemon to "Think before it Acts" for high-stakes decisions.
-
-Strategic Role:
-- Generates "Strategic Briefings" (Option A vs B).
-- Handles "Ratification" (User Approval) for Unshackled actions.
-- Updates Trust Scores based on successful outcomes.
-"""
-
-import json
-from datetime import datetime
-from pathlib import Path
-from typing import List, Dict, Optional
-from dataclasses import dataclass, asdict
-
-# Re-use our locking mechanism for safety
-from .locking import get_lock
-
-@dataclass
-class Proposal:
-    id: str
-    title: str
-    description: str
-    options: List[Dict[str, str]] # [{"id": "A", "desc": "Do X"}, {"id": "B", "desc": "Do Y"}]
-    risk_level: str # "low", "medium", "high", "critical"
-    created_at: str
-    status: str = "pending" # pending, ratified, rejected, executed
-    ratified_option_id: Optional[str] = None
-    
-class ProposalOps:
-    def __init__(self, brain_path: Path):
-        self.brain_path = brain_path
-        self.proposals_dir = brain_path / "ledger" / "proposals"
-        self.proposals_dir.mkdir(parents=True, exist_ok=True)
-        
-    def generate_proposal(self, title: str, description: str, options: List[Dict], risk_level: str = "medium") -> Proposal:
-        """Create a new decision proposal"""
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        pid = f"prop_{timestamp}"
-        
-        proposal = Proposal(
-            id=pid,
-            title=title,
-            description=description,
-            options=options,
-            risk_level=risk_level,
-            created_at=datetime.now().isoformat()
-        )
-        
-        self._save_proposal(proposal)
-        return proposal
-        
-    def _save_proposal(self, proposal: Proposal):
-        """Save proposal atomically"""
-        file_path = self.proposals_dir / f"{proposal.id}.json"
-        
-        with get_lock("proposals", self.brain_path).section():
-            with open(file_path, 'w') as f:
-                json.dump(asdict(proposal), f, indent=2)
-                
-    def get_pending_proposals(self) -> List[Proposal]:
-        """List all pending proposals"""
-        pending = []
-        # No lock needed for simple list unless we want strict consistency
-        if not self.proposals_dir.exists():
-            return []
-            
-        for f in self.proposals_dir.glob("prop_*.json"):
-            try:
-                data = json.loads(f.read_text())
-                if data.get("status") == "pending":
-                    pending.append(Proposal(**data))
-            except Exception:
-                pass
-        return pending
-
-    def ratify_proposal(self, proposal_id: str, option_id: str) -> bool:
-        """User validates a proposal"""
-        with get_lock("proposals", self.brain_path).section():
-            file_path = self.proposals_dir / f"{proposal_id}.json"
-            if not file_path.exists():
-                return False
-                
-            data = json.loads(file_path.read_text())
-            if data["status"] != "pending":
-                return False
-                
-            # Verify option exists
-            if not any(opt["id"] == option_id for opt in data["options"]):
-                return False
-                
-            data["status"] = "ratified"
-            data["ratified_option_id"] = option_id
-            data["ratified_at"] = datetime.now().isoformat()
-            
-            with open(file_path, 'w') as f:
-                json.dump(data, f, indent=2)
-                
-            return True

package/src/mcp_server_nucleus/runtime/publisher.py

@@ -1,109 +0,0 @@
-"""
-Publisher: The Shipping Department.
-Orchestrates the creation of Signed Agent Artifacts.
-
-Strategic Role:
-- VALIDATOR: Ensures Manifest is legal before packing.
-- SIGNER: Applies the Keymaster's seal.
-- PACKER: Creates the purely immutable .nuke file.
-"""
-
-import logging
-from pathlib import Path
-from typing import Optional
-
-from .identity.keygen import KeyManager
-from .identity.manifest import ManifestValidator
-from .nuke_protocol import NukePacker
-
-logger = logging.getLogger("PUBLISHER")
-
-class Publisher:
-    def __init__(self, brain_path: Path, key_manager: Optional[KeyManager] = None):
-        self.brain_path = brain_path
-        self.key_manager = key_manager or KeyManager(brain_path)
-        self.packer = NukePacker(staging_root=brain_path / "staging")
-        self.validator = ManifestValidator()
-
-    def publish(self, agent_source: Path, output_dir: Path, key_id: str, private: bool = False) -> Path:
-        """
-        Publish an agent from source directory.
-        
-        Args:
-            agent_source: Directory containing manifest.json and code.
-            output_dir: Where to save the .nuke artifact.
-            key_id: ID of the key to sign with.
-            private: If True, marks manifest as private (if supported).
-        
-        Returns:
-            Path to the generated .nuke file.
-        """
-        agent_source = Path(agent_source)
-        output_dir = Path(output_dir)
-        output_dir.mkdir(parents=True, exist_ok=True)
-        
-        logger.info(f"📦 Publishing agent from {agent_source}...")
-        
-        # 1. Validate Manifest
-        manifest_path = agent_source / "manifest.json"
-        if not manifest_path.exists():
-            raise FileNotFoundError("manifest.json missing in source")
-            
-        manifest_data = manifest_path.read_text()
-        import json
-        manifest_obj = json.loads(manifest_data)
-        if not self.validator.validate(manifest_obj):
-            raise ValueError("❌ Validation Failed: User's manifest is invalid.")
-            
-        # 2. Get Signature
-        # We need to sign the content. NukePacker.pack signs the manifest.
-        # Wait, NukePacker.pack takes a private_key_pem.
-        
-        try:
-            # Retrieve private key protected by KeyManager
-            # In Phase 57, KeyManager.get_key returns KeyPair (has private bytes)
-            # But get_key might return None.
-            # actually we don't have get_key exposed publicly easily without password?
-            # KeyManager.sign is the preferred way?
-            # NukePacker pack expects private_key_pem string.
-            
-            # Let's peek at KeyManager implementation via memory or usage.
-            # It loads from disk. 
-            # We'll use key_manager._load_key_pair(key_id) which is internal?
-            # Or assume KeyManager is initialized.
-            
-            # Better: KeyManager SHOULD handle signing. NukePacker should take a signer callback?
-            # For Phase 57, let's load the PEM.
-            
-            key_pair = self.key_manager.get_key_pair(key_id) # Assuming this exists or we need to add it
-            if not key_pair:
-                raise ValueError(f"Key ID {key_id} not found.")
-                
-            private_key_pem = key_pair.private_key_pem
-            
-            # 3. Collect Tools
-            # Naive scan for now: all .py files in source except manifest
-            tool_paths = list(agent_source.glob("*.py"))
-            
-            # 4. Pack & Sign
-            # Construct output filename: agent.id-version.nuke
-            # We must use the VALIDATED manifest object
-            from .identity.manifest import AgentManifest
-            validated_manifest = AgentManifest(**manifest_obj)
-            
-            artifact_filename = f"{validated_manifest.agent.id}-{validated_manifest.agent.version}.nuke"
-            final_artifact_path = output_dir / artifact_filename
-            
-            self.packer.pack(
-                manifest=validated_manifest,
-                tool_paths=tool_paths,
-                private_key_pem=private_key_pem,
-                output_path=final_artifact_path
-            )
-            
-            logger.info(f"✅ Published: {final_artifact_path}")
-            return final_artifact_path
-            
-        except Exception as e:
-            logger.error(f"❌ Publishing failed: {e}")
-            raise e