nucleus-mcp 1.0.7 → 1.2.0

package/src/mcp_server_nucleus/core/__init__.py

@@ -1,6 +0,0 @@
-"""
-Core Infrastructure Module
-"""
-
-from .tool_registration_impl import configure_tiered_tool_registration as configure_tiered_tool_registration
-from .orchestrator import get_orchestrator as get_orchestrator

package/src/mcp_server_nucleus/core/orchestrator.py

@@ -1,9 +0,0 @@
-"""
-Orchestrator Initialization Module
-"""
-
-# Lazy-loaded singleton for orchestrator access
-def get_orchestrator():
-    """Get the orchestrator singleton (Unified)."""
-    from .orchestrator_unified import get_orchestrator
-    return get_orchestrator()

package/src/mcp_server_nucleus/core/tool_registration_impl.py

@@ -1,99 +0,0 @@
-# Auto-generated from monolith decomposition
-# =============================================================================
-# v0.6.0 PROTOCOL COUPLING FIX - Tiered Tool Registration
-# =============================================================================
-# This wrapper ensures only tier-appropriate tools are registered with FastMCP.
-# Without this, ALL tools would be registered regardless of NUCLEUS_TOOL_TIER.
-# See: TITAN_HANDOVER_PROTOCOL.md Section 0 (Registry Bloat Solution)
-
-from ..tool_tiers import is_tool_allowed, tier_manager
-import sys
-
-# State flag to prevent recursion when FastMCP internally calls mcp.tool
-_REGISTERING_TOOL = False
-_original_mcp_tool = None
-
-def _tiered_tool_wrapper(*args, **kwargs):
-    """
-    Wrapper around mcp.tool() that checks tier before registration.
-    
-    Handles both decorator styles:
-    - @mcp.tool     (func passed directly)
-    - @mcp.tool()   (func is None, returns decorator)
-    """
-    global _REGISTERING_TOOL, _original_mcp_tool
-    
-    if _original_mcp_tool is None:
-        raise RuntimeError("Tiered tool registration not configured. Call configure_tiered_tool_registration(mcp) first.")
-
-    # If we are already in the middle of a registration, use the original method
-    if _REGISTERING_TOOL:
-        return _original_mcp_tool(*args, **kwargs)
-
-    func = None
-    if len(args) == 1 and callable(args[0]):
-        func = args[0]
-        args = args[1:]
-
-    def decorator(fn):
-        global _REGISTERING_TOOL
-        tool_name = fn.__name__
-        allowed = is_tool_allowed(tool_name)
-        if allowed:
-            tier_manager.registered_tools.add(tool_name)
-            
-            # Set flag and call original method
-            _REGISTERING_TOOL = True
-            try:
-                # Register and capture the FunctionTool return
-                tool = _original_mcp_tool(*args, **kwargs)(fn)
-                
-                # Make the FunctionTool object callable by proxying to the original function
-                if not callable(tool):
-                    class CallableTool:
-                        def __init__(self, tool, original_fn):
-                            self._tool = tool
-                            self._fn = original_fn
-                            # Copy metadata
-                            self.__name__ = original_fn.__name__
-                            self.__doc__ = original_fn.__doc__
-                            self.__module__ = original_fn.__module__
-                            
-                        def __call__(self, *args, **kwargs):
-                            print(f"[NUCLEUS] Executing {self.__name__}...", file=sys.stderr)
-                            return self._fn(*args, **kwargs)
-                            
-                        def __getattr__(self, name):
-                            return getattr(self._tool, name)
-                            
-                        # Pydantic serialization helpers
-                        def model_dump(self, *args, **kwargs):
-                            return self._tool.model_dump(*args, **kwargs)
-                            
-                        def model_dump_json(self, *args, **kwargs):
-                            return self._tool.model_dump_json(*args, **kwargs)
-                            
-                    return CallableTool(tool, fn)
-                
-                return tool
-            except Exception as e:
-                print(f"[NUCLEUS] ERROR registering {tool_name}: {e}", file=sys.stderr)
-                raise e
-            finally:
-                _REGISTERING_TOOL = False
-        else:
-            tier_manager.filtered_tools.add(tool_name)
-            # Return plain function - NOT registered with MCP
-            return fn
-    
-    if func is not None:
-        return decorator(func)
-    
-    return decorator
-
-def configure_tiered_tool_registration(mcp_instance):
-    """Initializes the tiered tool registration system for the given MCP instance."""
-    global _original_mcp_tool
-    _original_mcp_tool = mcp_instance.tool
-    mcp_instance.tool = _tiered_tool_wrapper
-    return mcp_instance

package/src/mcp_server_nucleus/daemon/safety/lock.py

@@ -1,121 +0,0 @@
-import fcntl
-import os
-import time
-import errno
-import logging
-from contextlib import contextmanager
-
-logger = logging.getLogger(__name__)
-
-class BrainLock:
-    """
-    The Atomic Guard for the Sovereign Brain.
-    
-    Implements cross-process file locking using fcntl.
-    Prevents race conditions between the MCP Server (User Interface)
-    and the Daemon (Background Worker).
-    
-    Principles:
-    1. Safety: Never corrupt the Graph.
-    2. Liveness: Auto-break stale locks (App crashes).
-    3. Atomicity: All or nothing.
-    """
-    
-    def __init__(self, lock_file: str, timeout: int = 5):
-        """
-        Initialize the BrainLock.
-        
-        Args:
-            lock_file: Path to the lock file (e.g., .brain/lock/state.lock)
-            timeout: Seconds to wait for lock acquisition before giving up.
-        """
-        self.lock_file = lock_file
-        self.timeout = timeout
-        self.fd = None
-        self._ensure_dir()
-
-    def _ensure_dir(self):
-        os.makedirs(os.path.dirname(self.lock_file), exist_ok=True)
-
-    def acquire(self) -> bool:
-        """
-        Acquire egg-lock. Blocking with timeout.
-        """
-        start_time = time.time()
-        while True:
-            try:
-                self.fd = open(self.lock_file, 'w')
-                # LOCK_EX: Exclusive Lock
-                # LOCK_NB: Non-blocking (fail immediately if locked)
-                fcntl.flock(self.fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
-                
-                # Write PID for debugging / stale detection
-                self.fd.write(str(os.getpid()))
-                self.fd.flush()
-                return True
-                
-            except IOError as e:
-                if self.fd:
-                    self.fd.close()
-                    self.fd = None
-                    
-                if e.errno != errno.EAGAIN:
-                    # Unexpected error
-                    logger.error(f"BrainLock Error: {e}")
-                    raise
-                    
-                # Locked by another process
-                if time.time() - start_time >= self.timeout:
-                    # Timeout reached
-                    logger.warning(f"BrainLock Acquisition Timeout: {self.lock_file}")
-                    return False
-                
-                # Wait and retry
-                time.sleep(0.1)
-
-    def release(self):
-        """
-        Release the lock.
-        """
-        if self.fd:
-            try:
-                # Remove the lock file content (optional, but clean)
-                self.fd.truncate(0)
-                fcntl.flock(self.fd, fcntl.LOCK_UN)
-            except Exception as e:
-                logger.error(f"BrainLock Release Error: {e}")
-            finally:
-                self.fd.close()
-                self.fd = None
-
-    @contextmanager
-    def guard(self):
-        """
-        Context Manager for 'with BrainLock(...):' syntax.
-        """
-        if not self.acquire():
-            raise TimeoutError(f"Could not acquire BrainLock on {self.lock_file}")
-        try:
-            yield
-        finally:
-            self.release()
-
-    @staticmethod
-    def is_locked(lock_file: str) -> bool:
-        """
-        Check if a file is currently locked without waiting.
-        """
-        if not os.path.exists(lock_file):
-            return False
-            
-        try:
-            fd = open(lock_file, 'r')
-            fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
-            # If we got here, it wasn't locked. Unlock and close.
-            fcntl.flock(fd, fcntl.LOCK_UN)
-            fd.close()
-            return False
-        except IOError as e:
-            if e.errno == errno.EAGAIN:
-                return True
-            raise

package/src/mcp_server_nucleus/deployment/render_integration.py

@@ -1,4 +0,0 @@
-# Auto-generated from monolith decomposition
-# ============================================================
-# RENDER POLLER (Deploy monitoring)
-# ============================================================

package/src/mcp_server_nucleus/hypervisor/injector.py

@@ -1,83 +0,0 @@
-
-import json
-import logging
-from pathlib import Path
-from typing import Dict, Any
-
-logger = logging.getLogger(__name__)
-
-class Injector:
-    """
-    The Nucleus Hypervisor Injection Primitive (Layer 2).
-    Dynamically injects context and identity into running IDEs by manipulating
-    configuration files that support hot-reloading (e.g., .vscode/settings.json).
-    """
-
-    def __init__(self, workspace_root: str):
-        self.workspace_root = Path(workspace_root)
-        self.vscode_settings_path = self.workspace_root / ".vscode" / "settings.json"
-
-    def _ensure_vscode_dir(self):
-        if not self.vscode_settings_path.parent.exists():
-            self.vscode_settings_path.parent.mkdir(parents=True, exist_ok=True)
-
-    def _read_settings(self) -> Dict[str, Any]:
-        if not self.vscode_settings_path.exists():
-            return {}
-        try:
-            # Handle comments in JSON if necessary (standard json lib doesn't, but VSCode allows them)
-            # For now, assuming standard JSON or we overwrite.
-            # Ideally use a comment-preserving parser, but simple JSON is safer for machine-control.
-            return json.loads(self.vscode_settings_path.read_text())
-        except Exception as e:
-            logger.warning(f"Failed to read settings.json: {e}")
-            return {}
-
-    def _write_settings(self, settings: Dict[str, Any]) -> bool:
-        try:
-            self._ensure_vscode_dir()
-            self.vscode_settings_path.write_text(json.dumps(settings, indent=4))
-            return True
-        except Exception as e:
-            logger.error(f"Failed to write settings.json: {e}")
-            return False
-
-    def inject_identity(self, identity: str, color_hex: str) -> bool:
-        """
-        Injects visual identity markers into VSCode settings.
-        """
-        settings = self._read_settings()
-        
-        # Inject standard visual cues
-        settings["workbench.colorCustomizations"] = settings.get("workbench.colorCustomizations", {})
-        settings["workbench.colorCustomizations"]["titleBar.activeBackground"] = color_hex
-        settings["workbench.colorCustomizations"]["titleBar.activeForeground"] = "#ffffff"
-        settings["workbench.colorCustomizations"]["activityBar.background"] = color_hex
-        
-        # Inject status bar message (if possible via extension, or just window title)
-        settings["window.title"] = f"[{identity.upper()}] ${{rootName}}"
-        
-        # Inject context-specific file exclusions if needed
-        # e.g., if Red Team, hide 'build' folder?
-        
-        return self._write_settings(settings)
-
-    def reset_identity(self) -> bool:
-        """
-        Removes injected identity markers.
-        """
-        settings = self._read_settings()
-        
-        if "workbench.colorCustomizations" in settings:
-            # Remove our specific keys
-            for key in ["titleBar.activeBackground", "titleBar.activeForeground", "activityBar.background"]:
-                settings["workbench.colorCustomizations"].pop(key, None)
-            
-            # If empty, remove the whole object
-            if not settings["workbench.colorCustomizations"]:
-                del settings["workbench.colorCustomizations"]
-                
-        if "window.title" in settings:
-            del settings["window.title"]
-            
-        return self._write_settings(settings)

package/src/mcp_server_nucleus/hypervisor/locker.py

@@ -1,130 +0,0 @@
-
-import subprocess
-import os
-import logging
-from typing import List
-
-logger = logging.getLogger(__name__)
-
-class Locker:
-    """
-    The Nucleus Hypervisor Locking Primitive (Layer 4).
-    Uses macOS 'chflags' (immutable flags) to enforce file-system level write protection.
-    This prevents even root/sudo users (and other agents) from modifying locked files
-    until the lock is explicitly released.
-    """
-
-    def __init__(self):
-        pass
-
-    def _run_cmd(self, cmd: List[str]) -> bool:
-        try:
-            subprocess.run(
-                cmd, 
-                capture_output=True, 
-                text=True, 
-                check=True
-            )
-            return True
-        except subprocess.CalledProcessError as e:
-            logger.error(f"Locker Command Failed: {e.stderr}")
-            return False
-
-    def lock(self, path: str, metadata: dict = None) -> bool:
-        """
-        Locks a file or directory using 'chflags uchg'.
-        If path is a directory, it locks it recursively? 
-        Current implementation: Single file/folder lock (non-recursive by default for safety).
-        To do recursive: chflags -R uchg
-        """
-        if not os.path.exists(path):
-            logger.error(f"Cannot lock non-existent path: {path}")
-            return False
-            
-        logger.info(f"🔒 Locking: {path}")
-
-        # Apply metadata BEFORE making immutable
-        if metadata:
-            import time
-            if "timestamp" not in metadata:
-                metadata["timestamp"] = time.strftime("%Y-%m-%dT%H:%M:%S%z")
-            
-            for k, v in metadata.items():
-                key = k if k.startswith("nucleus.lock.") else f"nucleus.lock.{k}"
-                # If directory, apply only to the directory itself for now (recursive xattr is tricky)
-                self._set_xattr(path, key, v)
-
-        # Using -R (recursive) to lock entire directories if needed
-        if os.path.isdir(path):
-            return self._run_cmd(["chflags", "-R", "uchg", path])
-        else:
-            return self._run_cmd(["chflags", "uchg", path])
-
-    def unlock(self, path: str) -> bool:
-        """
-        Unlocks a file or directory using 'chflags nouchg'.
-        """
-        if not os.path.exists(path):
-            logger.error(f"Cannot unlock non-existent path: {path}")
-            return False
-
-        logger.info(f"🔓 Unlocking: {path}")
-        if os.path.isdir(path):
-            return self._run_cmd(["chflags", "-R", "nouchg", path])
-        else:
-            return self._run_cmd(["chflags", "nouchg", path])
-
-    def is_locked(self, path: str) -> bool:
-        """
-        Checks if the file has the 'uchg' flag set.
-        """
-        if not os.path.exists(path):
-            return False
-        
-        # 'ls -lz' shows flags on macOS, or 'ls -MdO'
-        # simpler: stat
-        try:
-            st = os.stat(path)
-            # 0x2 is UF_IMMUTABLE (uchg)
-            return (st.st_flags & 0x2) != 0
-        except Exception:
-            return False
-
-    # --- METADATA (Phase 28) ---
-    def _set_xattr(self, path: str, key: str, value: str):
-        try:
-            subprocess.run(
-                ["xattr", "-w", key, str(value), path],
-                check=True,
-                capture_output=True
-            )
-        except subprocess.CalledProcessError as e:
-            logger.warning(f"Failed to set xattr {key}: {e}")
-
-    def get_metadata(self, path: str) -> dict:
-        """Retrieves lock metadata from xattrs."""
-        if not os.path.exists(path):
-            return {}
-        
-        try:
-            result = subprocess.run(
-                ["xattr", path],
-                check=True,
-                capture_output=True,
-                text=True
-            )
-            keys = result.stdout.strip().split("\n")
-            data = {}
-            for key in keys:
-                if key.startswith("nucleus.lock."):
-                    val = subprocess.run(
-                        ["xattr", "-p", key, path],
-                        check=True,
-                        capture_output=True,
-                        text=True
-                    ).stdout.strip()
-                    clean_key = key.replace("nucleus.lock.", "")
-                    data[clean_key] = val
-            return data
-        except Exception:
-            return {}

package/src/mcp_server_nucleus/hypervisor/watchdog.py

@@ -1,71 +0,0 @@
-
-import logging
-from pathlib import Path
-from watchdog.observers import Observer
-from watchdog.events import FileSystemEventHandler
-
-from .locker import Locker
-
-logger = logging.getLogger(__name__)
-
-class SecurityEventHandler(FileSystemEventHandler):
-    """
-    Handles file events for the Hypervisor Watchdog.
-    Detects attempts to modify locked files.
-    """
-    def __init__(self, watchdog_instance, locker: Locker):
-        self.watchdog = watchdog_instance
-        self.locker = locker
-
-    def on_modified(self, event):
-        if event.is_directory:
-            return
-        
-        path = str(Path(event.src_path).resolve())
-        is_protected = False
-        
-        # Access live list from watchdog instance
-        for p_path in self.watchdog.protected_paths:
-            if path == p_path or path.startswith(p_path + "/"):
-                is_protected = True
-                break
-        
-        if is_protected:
-            # Breach Detected!
-            logger.warning(f"🚨 SECURITY BREACH: Locked file modified: {path}")
-            
-            # 1. Immediate Re-Lock (in case it was unlocked)
-            self.locker.lock(path)
-            
-            # 2. (Future) Revert from Shadow Copy
-            # self.revert(path)
-
-class Watchdog:
-    """
-    The Nucleus Hypervisor Sentinel (Layer 1).
-    Monitors critical files and reinforces locks.
-    """
-    def __init__(self, workspace_root: str):
-        self.workspace_root = Path(workspace_root)
-        self.locker = Locker()
-        self.observer = Observer()
-        self.protected_paths = []
-
-    def protect(self, path: str):
-        """Adds a path to the protected list and starts watching it."""
-        abs_path = str((self.workspace_root / path).resolve())
-        if abs_path not in self.protected_paths:
-            self.protected_paths.append(abs_path)
-            # Ensure it is physically locked
-            self.locker.lock(abs_path)
-    
-    def start(self):
-        """Starts the background monitoring thread."""
-        handler = SecurityEventHandler(self, self.locker)
-        self.observer.schedule(handler, str(self.workspace_root), recursive=True)
-        self.observer.start()
-        logger.info(f"👁️ Hypervisor Watchdog started on {self.workspace_root}")
-
-    def stop(self):
-        self.observer.stop()
-        self.observer.join()

package/src/mcp_server_nucleus/runtime/__init__.py

@@ -1,58 +0,0 @@
-"""
-Nucleus Agent Runtime - Runtime Package
-
-v0.6.0 DSoR: Added context_manager and ipc_auth for decision provenance.
-"""
-
-from .factory import ContextFactory
-from .agent import EphemeralAgent, DecisionMade, ActionRequested
-from .event_stream import EventSeverity, EventTypes, emit_event, read_events
-from .triggers import match_triggers, get_agents_for_event
-from .profiling import (
-    timed, timed_io, timed_compute, timed_llm,
-    get_metrics, get_metrics_summary, reset_metrics, export_metrics_to_file
-)
-# v0.6.0 DSoR Components
-from .context_manager import (
-    ContextManager, ContextSnapshot, StateVerificationResult,
-    get_context_manager, compute_context_hash, verify_turn_integrity
-)
-from .ipc_auth import (
-    IPCAuthManager, IPCToken, TokenMeterEntry,
-    get_ipc_auth_manager, require_ipc_token
-)
-
-__all__ = [
-    "ContextFactory",
-    "EphemeralAgent",
-    "DecisionMade",
-    "ActionRequested",
-    "EventSeverity",
-    "EventTypes",
-    "emit_event",
-    "read_events",
-    "match_triggers",
-    "get_agents_for_event",
-    # Profiling (AG-014)
-    "timed",
-    "timed_io",
-    "timed_compute", 
-    "timed_llm",
-    "get_metrics",
-    "get_metrics_summary",
-    "reset_metrics",
-    "export_metrics_to_file",
-    # v0.6.0 DSoR - Context Manager
-    "ContextManager",
-    "ContextSnapshot",
-    "StateVerificationResult",
-    "get_context_manager",
-    "compute_context_hash",
-    "verify_turn_integrity",
-    # v0.6.0 DSoR - IPC Auth
-    "IPCAuthManager",
-    "IPCToken",
-    "TokenMeterEntry",
-    "get_ipc_auth_manager",
-    "require_ipc_token"
-]