nucleus-mcp 1.0.7 → 1.2.0

package/src/mcp_server_nucleus/runtime/fetcher.py

@@ -1,92 +0,0 @@
-"""
-GitFetcher: The Supply Line.
-Securely clones and checks out specific commits of Agent Repositories.
-
-Strategic Role:
-- "The Truck": Moves bytes from GitHub to Nucleus.
-- "Immutable": Always checks out a specific hash (The Stamp).
-- "Secure": Validates URLs and prevents command injection.
-"""
-
-import logging
-import shutil
-import subprocess
-from pathlib import Path
-
-logger = logging.getLogger("GIT_FETCHER")
-
-class GitFetcher:
-    def __init__(self):
-        pass
-
-    def fetch(self, url: str, destination: Path, commit_hash: str) -> Path:
-        """
-        Clones a repo to destination and checks out a specific commit.
-        
-        Args:
-            url: Git URL (https://github.com/... or file://...)
-            destination: Local path to install to.
-            commit_hash: The SHA-1 hash to checkout.
-        
-        Returns:
-            Path to the checked out directory (destination).
-        """
-        destination = Path(destination)
-        
-        logger.info(f"🚚 Fetching {url} -> {destination} @ {commit_hash[:7]}")
-        
-        # 1. Cleanup target if exists
-        if destination.exists():
-            shutil.rmtree(destination)
-        destination.mkdir(parents=True)
-        
-        try:
-            # 2. Clone (No checkout initially for speed/safety)
-            # We use subprocess directly to avoid external lib dependencies like GitPython
-            # for this core component.
-            
-            # Note: We clone to a temp folder inside destination or directly?
-            # Git won't clone into non-empty dir usually.
-            # But we just cleared it.
-            
-            subprocess.check_call(
-                ["git", "clone", "--no-checkout", url, "."], 
-                cwd=destination,
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.PIPE
-            )
-            
-            # 3. Checkout Specific Hash
-            subprocess.check_call(
-                ["git", "checkout", commit_hash], 
-                cwd=destination,
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.PIPE
-            )
-            
-            # 4. Verify Head (Paranoid Check)
-            current_hash = subprocess.check_output(
-                ["git", "rev-parse", "HEAD"], 
-                cwd=destination
-            ).decode().strip()
-            
-            if current_hash != commit_hash:
-                raise ValueError(f"Hash Mismatch! Requested {commit_hash}, got {current_hash}")
-                
-            # 5. Cleanup .git folder? 
-            # Phase 57 Spec says "The Stamp" is the commit hash.
-            # We might want to keep .git for provenance or remove it for "frozen" artifact.
-            # NukePacker wraps the RESULT. So this is just a staging step.
-            # Let's clean up .git to ensure it's a pure artifact source.
-            shutil.rmtree(destination / ".git")
-            
-            logger.info("✅ Fetch & Checkout Verified.")
-            return destination
-            
-        except subprocess.CalledProcessError as e:
-            # Capture stderr for better error
-            raise RuntimeError(f"Git Command Failed: {e}")
-        except Exception as e:
-            if destination.exists():
-                shutil.rmtree(destination)
-            raise e

package/src/mcp_server_nucleus/runtime/file_monitor.py

@@ -1,208 +0,0 @@
-"""
-File Monitor - Phase 50 Implementation
-======================================
-Watches the .brain folder for changes and emits events.
-
-This is the core of "Native Sync" (Tiers 1-3 in NUCLEUS_PRODUCT_SPECS.md).
-When a file changes, we notify all connected MCP clients.
-
-Usage:
-    monitor = FileMonitor(brain_path)
-    monitor.start()
-    # ... later
-    monitor.stop()
-"""
-
-import os
-import threading
-import logging
-from pathlib import Path
-from typing import Callable, Optional, List
-from dataclasses import dataclass, field
-from datetime import datetime
-
-try:
-    from watchdog.observers import Observer
-    from watchdog.events import FileSystemEventHandler, FileSystemEvent
-    WATCHDOG_AVAILABLE = True
-except ImportError:
-    WATCHDOG_AVAILABLE = False
-    Observer = None
-    FileSystemEventHandler = object
-    FileSystemEvent = None
-
-logger = logging.getLogger("nucleus.file_monitor")
-
-
-@dataclass
-class FileChangeEvent:
-    """Represents a file change in the brain folder."""
-    event_type: str  # created, modified, deleted, moved
-    path: str
-    timestamp: datetime = field(default_factory=datetime.now)
-    is_directory: bool = False
-    
-    def to_dict(self) -> dict:
-        return {
-            "event_type": self.event_type,
-            "path": self.path,
-            "timestamp": self.timestamp.isoformat(),
-            "is_directory": self.is_directory
-        }
-
-
-class BrainEventHandler(FileSystemEventHandler):
-    """Handles file system events in the .brain folder."""
-    
-    def __init__(self, callback: Callable[[FileChangeEvent], None]):
-        self.callback = callback
-        self._debounce_cache: dict = {}
-        self._debounce_ms = 100  # Ignore duplicate events within 100ms
-        
-    def _should_ignore(self, path: str) -> bool:
-        """Ignore temporary files, caches, and hidden files."""
-        basename = os.path.basename(path)
-        ignored_patterns = [
-            '.DS_Store',
-            '__pycache__',
-            '.git',
-            '*.pyc',
-            '*.swp',
-            '*.tmp',
-            '.resolved.',  # Archive backup files
-        ]
-        for pattern in ignored_patterns:
-            if pattern.startswith('*'):
-                if basename.endswith(pattern[1:]):
-                    return True
-            elif pattern in basename:
-                return True
-        return False
-    
-    def _debounce(self, path: str) -> bool:
-        """Return True if we should process this event (not debounced)."""
-        now = datetime.now()
-        key = path
-        if key in self._debounce_cache:
-            last_time = self._debounce_cache[key]
-            if (now - last_time).total_seconds() * 1000 < self._debounce_ms:
-                return False
-        self._debounce_cache[key] = now
-        return True
-    
-    def _emit(self, event_type: str, event: FileSystemEvent):
-        """Emit a file change event."""
-        if self._should_ignore(event.src_path):
-            return
-        if not self._debounce(event.src_path):
-            return
-            
-        change = FileChangeEvent(
-            event_type=event_type,
-            path=event.src_path,
-            is_directory=event.is_directory
-        )
-        logger.debug(f"File change detected: {change.event_type} -> {change.path}")
-        self.callback(change)
-    
-    def on_created(self, event):
-        self._emit("created", event)
-    
-    def on_modified(self, event):
-        self._emit("modified", event)
-    
-    def on_deleted(self, event):
-        self._emit("deleted", event)
-    
-    def on_moved(self, event):
-        self._emit("moved", event)
-
-
-class FileMonitor:
-    """
-    Monitors the .brain folder for file changes.
-    
-    This enables "push" notifications to MCP clients when files change,
-    solving the sync problem across Chats/IDEs/CLI.
-    """
-    
-    def __init__(self, brain_path: str, on_change: Optional[Callable[[FileChangeEvent], None]] = None):
-        self.brain_path = Path(brain_path)
-        self.on_change = on_change or self._default_handler
-        self._observer: Optional[Observer] = None
-        self._running = False
-        self._event_queue: List[FileChangeEvent] = []
-        self._lock = threading.Lock()
-        
-        if not WATCHDOG_AVAILABLE:
-            logger.warning("watchdog library not installed. File monitoring disabled.")
-    
-    def _default_handler(self, event: FileChangeEvent):
-        """Default handler just logs and queues events."""
-        with self._lock:
-            self._event_queue.append(event)
-            # Keep queue bounded
-            if len(self._event_queue) > 100:
-                self._event_queue = self._event_queue[-50:]
-    
-    def start(self) -> bool:
-        """Start watching the brain folder."""
-        if not WATCHDOG_AVAILABLE:
-            logger.error("Cannot start file monitor: watchdog not installed.")
-            return False
-            
-        if self._running:
-            logger.warning("File monitor already running.")
-            return True
-            
-        if not self.brain_path.exists():
-            logger.warning(f"Brain path does not exist: {self.brain_path}")
-            return False
-        
-        try:
-            handler = BrainEventHandler(self.on_change)
-            self._observer = Observer()
-            self._observer.schedule(handler, str(self.brain_path), recursive=True)
-            self._observer.start()
-            self._running = True
-            logger.info(f"📡 File monitor started: {self.brain_path}")
-            return True
-        except Exception as e:
-            logger.error(f"Failed to start file monitor: {e}")
-            return False
-    
-    def stop(self):
-        """Stop watching the brain folder."""
-        if self._observer and self._running:
-            self._observer.stop()
-            self._observer.join(timeout=2)
-            self._running = False
-            logger.info("📡 File monitor stopped.")
-    
-    def get_pending_events(self) -> List[FileChangeEvent]:
-        """Get and clear pending events."""
-        with self._lock:
-            events = self._event_queue.copy()
-            self._event_queue.clear()
-            return events
-    
-    @property
-    def is_running(self) -> bool:
-        return self._running
-
-
-# Singleton instance for global access
-_global_monitor: Optional[FileMonitor] = None
-
-
-def get_file_monitor() -> Optional[FileMonitor]:
-    """Get the global file monitor instance."""
-    return _global_monitor
-
-
-def init_file_monitor(brain_path: str, on_change: Optional[Callable] = None) -> FileMonitor:
-    """Initialize and return the global file monitor."""
-    global _global_monitor
-    if _global_monitor is None:
-        _global_monitor = FileMonitor(brain_path, on_change)
-    return _global_monitor

package/src/mcp_server_nucleus/runtime/firestore_bridge.py

@@ -1,91 +0,0 @@
-"""
-Nucleus Firestore Bridge
-========================
-Bridges the Local Brain (CLI) with the Cloud Brain (Orchestrator) via Firestore.
-
-Logic:
-- When an event is emitted locally, we push it to the 'nucleus-events' collection.
-- This allows the Cloud Orchestrator to see local events (like "Task Added").
-
-Location: mcp_server_nucleus/runtime/firestore_bridge.py
-"""
-
-import logging
-from typing import Dict, Any
-
-try:
-    from google.cloud import firestore
-    HAS_FIRESTORE = True
-except ImportError:
-    HAS_FIRESTORE = False
-
-logger = logging.getLogger(__name__)
-
-# Configuration
-PROJECT_ID = "gen-lang-client-0894185576"
-COLLECTION_NAME = "nucleus-events"
-
-class FirestoreBridge:
-    def __init__(self, project_id: str = PROJECT_ID):
-        self.project_id = project_id
-        self.client = None
-        self.enabled = False
-        
-        # Only enable if we have the library and credentials (or can get them)
-        if HAS_FIRESTORE:
-            try:
-                # This will use Application Default Credentials (gcloud auth application-default login)
-                self.client = firestore.Client(project=project_id)
-                self.enabled = True
-            except Exception as e:
-                logger.debug(f"Firestore Bridge disabled (no creds): {e}")
-                
-    def push_event(self, event: Dict[str, Any]) -> bool:
-        """Push a local event to the cloud."""
-        if not self.enabled or not self.client:
-            return False
-            
-        try:
-            # key by event_id for idempotency
-            event_id = event.get("event_id")
-            if not event_id:
-                return False
-                
-            doc_ref = self.client.collection(COLLECTION_NAME).document(event_id)
-            doc_ref.set(event)
-            return True
-        except Exception as e:
-            logger.warning(f"Failed to push event to cloud: {e}")
-            return False
-
-    def list_cloud_tasks(self, limit: int = 50) -> list:
-        """Fetch tasks from the cloud 'nucleus-tasks' collection."""
-        if not self.enabled or not self.client:
-            return []
-            
-        try:
-            # We assume cloud tasks are in 'nucleus-tasks'
-            # Ordered by priority (asc) and created_at (desc)
-            docs = self.client.collection("nucleus-tasks") \
-                .order_by("priority", direction=firestore.Query.ASCENDING) \
-                .limit(limit) \
-                .stream()
-                
-            tasks = []
-            for doc in docs:
-                t = doc.to_dict()
-                t["source"] = "cloud" # Mark as cloud source
-                tasks.append(t)
-            return tasks
-        except Exception as e:
-            logger.warning(f"Failed to list cloud tasks: {e}")
-            return []
-
-# Singleton instance
-_bridge = None
-
-def get_bridge() -> FirestoreBridge:
-    global _bridge
-    if _bridge is None:
-        _bridge = FirestoreBridge()
-    return _bridge

package/src/mcp_server_nucleus/runtime/gcloud_ops.py

@@ -1,186 +0,0 @@
-"""
-GCloud Ops - Phase 49 Implementation
-====================================
-Wraps the local `gcloud` CLI to query infrastructure state.
-
-This enables "Smooth across IDEs and CLI" (Tier 4 in NUCLEUS_PRODUCT_SPECS.md).
-The agent becomes the DevOps engineer using YOUR local gcloud auth.
-
-Usage:
-    ops = GCloudOps()
-    status = ops.get_cloud_run_services()
-"""
-
-import os
-import json
-import subprocess
-import shutil
-import logging
-from typing import Optional, List, Dict, Any
-from dataclasses import dataclass
-
-logger = logging.getLogger("nucleus.gcloud_ops")
-
-
-def find_gcloud() -> Optional[str]:
-    """Find gcloud binary in PATH or common locations."""
-    # 1. Check PATH
-    gcloud_path = shutil.which("gcloud")
-    if gcloud_path:
-        return gcloud_path
-    
-    # 2. Check common locations (Mac/Linux)
-    common_paths = [
-        os.path.expanduser("~/google-cloud-sdk/bin/gcloud"),
-        "/usr/local/bin/gcloud",
-        "/opt/homebrew/bin/gcloud",
-        "/usr/bin/gcloud",
-        # Homebrew on Apple Silicon
-        "/opt/homebrew/Caskroom/google-cloud-sdk/latest/google-cloud-sdk/bin/gcloud",
-    ]
-    for p in common_paths:
-        if os.path.exists(p):
-            return p
-    
-    return None
-
-
-@dataclass
-class GCloudResult:
-    """Result of a gcloud command."""
-    success: bool
-    data: Any = None
-    error: Optional[str] = None
-    command: str = ""
-    
-    def to_dict(self) -> dict:
-        return {
-            "success": self.success,
-            "data": self.data,
-            "error": self.error,
-            "command": self.command
-        }
-
-
-class GCloudOps:
-    """
-    Wraps gcloud CLI for infrastructure queries.
-    
-    Uses the user's local gcloud authentication - no API keys needed.
-    """
-    
-    def __init__(self, project: Optional[str] = None, region: str = "us-central1"):
-        self.gcloud_path = find_gcloud()
-        self.project = project or os.environ.get("GCLOUD_PROJECT")
-        self.region = region
-        
-    @property
-    def is_available(self) -> bool:
-        """Check if gcloud is available."""
-        return self.gcloud_path is not None
-    
-    def _run(self, args: List[str], format_json: bool = True) -> GCloudResult:
-        """Run a gcloud command and return result."""
-        if not self.is_available:
-            return GCloudResult(
-                success=False,
-                error="gcloud CLI not found. Install: https://cloud.google.com/sdk/docs/install",
-                command=" ".join(args)
-            )
-        
-        cmd = [self.gcloud_path] + args
-        if format_json:
-            cmd.extend(["--format", "json"])
-        
-        full_cmd = " ".join(cmd)
-        
-        try:
-            result = subprocess.run(
-                cmd,
-                capture_output=True,
-                text=True,
-                timeout=30
-            )
-            
-            if result.returncode != 0:
-                return GCloudResult(
-                    success=False,
-                    error=result.stderr.strip() or f"Command failed with exit code {result.returncode}",
-                    command=full_cmd
-                )
-            
-            if format_json and result.stdout.strip():
-                try:
-                    data = json.loads(result.stdout)
-                except json.JSONDecodeError:
-                    data = result.stdout.strip()
-            else:
-                data = result.stdout.strip()
-            
-            return GCloudResult(success=True, data=data, command=full_cmd)
-            
-        except subprocess.TimeoutExpired:
-            return GCloudResult(
-                success=False,
-                error="Command timed out (30s)",
-                command=full_cmd
-            )
-        except Exception as e:
-            return GCloudResult(
-                success=False,
-                error=str(e),
-                command=full_cmd
-            )
-    
-    def get_current_project(self) -> GCloudResult:
-        """Get the current active project."""
-        return self._run(["config", "get-value", "project"], format_json=False)
-    
-    def get_account(self) -> GCloudResult:
-        """Get the current authenticated account."""
-        return self._run(["config", "get-value", "account"], format_json=False)
-    
-    def list_cloud_run_services(self, project: Optional[str] = None) -> GCloudResult:
-        """List Cloud Run services."""
-        args = ["run", "services", "list"]
-        if project or self.project:
-            args.extend(["--project", project or self.project])
-        args.extend(["--region", self.region])
-        return self._run(args)
-    
-    def get_cloud_run_service(self, service_name: str, project: Optional[str] = None) -> GCloudResult:
-        """Get details of a specific Cloud Run service."""
-        args = ["run", "services", "describe", service_name]
-        if project or self.project:
-            args.extend(["--project", project or self.project])
-        args.extend(["--region", self.region])
-        return self._run(args)
-    
-    def get_cloud_run_revisions(self, service_name: str, project: Optional[str] = None) -> GCloudResult:
-        """List revisions for a Cloud Run service."""
-        args = ["run", "revisions", "list", "--service", service_name]
-        if project or self.project:
-            args.extend(["--project", project or self.project])
-        args.extend(["--region", self.region])
-        return self._run(args)
-    
-    def check_auth_status(self) -> Dict[str, Any]:
-        """Check overall gcloud authentication status."""
-        return {
-            "gcloud_available": self.is_available,
-            "gcloud_path": self.gcloud_path,
-            "project": self.get_current_project().data if self.is_available else None,
-            "account": self.get_account().data if self.is_available else None,
-        }
-
-
-# Singleton instance
-_gcloud_ops: Optional[GCloudOps] = None
-
-
-def get_gcloud_ops() -> GCloudOps:
-    """Get or create the global GCloudOps instance."""
-    global _gcloud_ops
-    if _gcloud_ops is None:
-        _gcloud_ops = GCloudOps()
-    return _gcloud_ops