nucleus-mcp 1.0.7 → 1.2.0

package/src/mcp_server_nucleus/runtime/triggers.py

@@ -1,237 +0,0 @@
-"""
-Nucleus Agent Runtime - Neural Triggers
-========================================
-The routing layer that matches events to agents.
-Events trigger agents based on configurable rules.
-
-Location: mcp_server_nucleus/runtime/triggers.py
-"""
-
-import json
-from pathlib import Path
-from typing import Dict, List, Optional
-
-
-def get_triggers_path(brain_path: Path) -> Path:
-    """Get path to triggers configuration"""
-    return brain_path / "ledger" / "triggers.json"
-
-
-def load_triggers(brain_path: Path) -> Dict:
-    """Load trigger definitions from disk"""
-    triggers_path = get_triggers_path(brain_path)
-    
-    if triggers_path.exists():
-        return json.loads(triggers_path.read_text())
-    
-    # Return default triggers
-    return get_default_triggers()
-
-
-def get_default_triggers() -> Dict:
-    """
-    Default trigger definitions based on .brain/agents/*.md protocols.
-    Maps events to the agents that should handle them.
-    """
-    return {
-        "version": "1.0",
-        "triggers": [
-            # Task Assignment (any agent)
-            {
-                "id": "task-assigned",
-                "event_type": "task_assigned",
-                "condition": "always",
-                "activates": "{{payload.target_agent}}",  # Dynamic from payload
-                "description": "Route task to specified agent"
-            },
-            
-            # Implementation → Critic Review
-            {
-                "id": "impl-complete-review",
-                "event_type": "implementation_complete",
-                "condition": "always",
-                "activates": "critic",
-                "description": "Developer finished, Critic reviews"
-            },
-            
-            # Strategy Update → Critic Validation
-            {
-                "id": "strategy-validation",
-                "event_type": "strategy_updated",
-                "condition": "always",
-                "activates": "critic",
-                "description": "Strategy changed, Critic validates coherence"
-            },
-            
-            # Spec Ready → Developer Implementation
-            {
-                "id": "spec-to-dev",
-                "event_type": "spec_ready_for_development",
-                "condition": "always",
-                "activates": "developer",
-                "description": "Architect finished spec, Developer implements"
-            },
-            
-            # Review Approved → DevOps Deploy
-            {
-                "id": "approved-to-deploy",
-                "event_type": "review_approved",
-                "condition": "payload.review_type == 'code'",
-                "activates": "devops",
-                "description": "Code approved, DevOps can deploy"
-            },
-            
-            # Critical Events → Synthesizer Escalation
-            {
-                "id": "critical-escalation",
-                "event_type": "*",
-                "condition": "severity == 'CRITICAL'",
-                "activates": "synthesizer",
-                "description": "Any critical event escalates to Synthesizer"
-            },
-            
-            # Sprint Started → Research Kick-off
-            {
-                "id": "sprint-research",
-                "event_type": "sprint_started",
-                "condition": "always",
-                "activates": "researcher",
-                "description": "New sprint, Researcher gathers context"
-            }
-        ]
-    }
-
-
-def save_triggers(brain_path: Path, triggers: Dict) -> None:
-    """Save trigger definitions to disk"""
-    triggers_path = get_triggers_path(brain_path)
-    triggers_path.parent.mkdir(parents=True, exist_ok=True)
-    triggers_path.write_text(json.dumps(triggers, indent=2))
-
-
-def evaluate_condition(condition: str, event: Dict) -> bool:
-    """
-    Evaluate a trigger condition against an event.
-    Supports:
-    - "always" - always matches
-    - "severity == 'CRITICAL'" - severity check
-    - "payload.field == 'value'" - payload field check
-    """
-    if condition == "always":
-        return True
-    
-    # Simple expression evaluation (safe subset)
-    try:
-        # Extract variables from event
-        severity = event.get("severity", "ROUTINE")
-        payload = event.get("payload", {})
-        event_type = event.get("event_type", "")
-        
-        # Basic condition parsing
-        if "severity ==" in condition:
-            target = condition.split("==")[1].strip().strip("'\"")
-            return severity == target
-        
-        if "payload." in condition:
-            # e.g., "payload.review_type == 'code'"
-            parts = condition.split("==")
-            field_path = parts[0].strip().replace("payload.", "")
-            target = parts[1].strip().strip("'\"")
-            return payload.get(field_path) == target
-        
-        if "event_type ==" in condition:
-            target = condition.split("==")[1].strip().strip("'\"")
-            return event_type == target
-        
-    except Exception:
-        pass
-    
-    return False
-
-
-def resolve_agent(activates: str, event: Dict) -> Optional[str]:
-    """
-    Resolve the agent name from the trigger.
-    Supports dynamic references like {{payload.target_agent}}
-    """
-    if activates.startswith("{{") and activates.endswith("}}"):
-        # Dynamic reference
-        path = activates[2:-2].strip()
-        
-        if path.startswith("payload."):
-            field = path.replace("payload.", "")
-            return event.get("payload", {}).get(field)
-        
-        return event.get(path)
-    
-    # Static agent name
-    return activates
-
-
-def match_triggers(brain_path: Path, event: Dict) -> List[Dict]:
-    """
-    Find all triggers that match an event.
-    Returns list of matched triggers with resolved agent names.
-    """
-    triggers_config = load_triggers(brain_path)
-    triggers = triggers_config.get("triggers", [])
-    matched = []
-    
-    event_type = event.get("event_type") or event.get("type", "")
-    
-    for trigger in triggers:
-        trigger_event_type = trigger.get("event_type", "")
-        
-        # Check event type match
-        if trigger_event_type != "*" and trigger_event_type != event_type:
-            continue
-        
-        # Check condition
-        condition = trigger.get("condition", "always")
-        if not evaluate_condition(condition, event):
-            continue
-        
-        # Resolve agent
-        agent = resolve_agent(trigger.get("activates", ""), event)
-        if not agent:
-            continue
-        
-        matched.append({
-            "trigger_id": trigger.get("id"),
-            "agent": agent,
-            "description": trigger.get("description", ""),
-            "event": event
-        })
-    
-    return matched
-
-
-def get_agents_for_event(brain_path: Path, event: Dict) -> List[str]:
-    """
-    Simple helper: get list of agent names that should be activated for an event.
-    """
-    matched = match_triggers(brain_path, event)
-    return list(set(m["agent"] for m in matched))
-
-
-def add_trigger(brain_path: Path, trigger: Dict) -> None:
-    """Add a new trigger definition"""
-    triggers_config = load_triggers(brain_path)
-    triggers_config["triggers"].append(trigger)
-    save_triggers(brain_path, triggers_config)
-
-
-def remove_trigger(brain_path: Path, trigger_id: str) -> bool:
-    """Remove a trigger by ID"""
-    triggers_config = load_triggers(brain_path)
-    original_count = len(triggers_config["triggers"])
-    triggers_config["triggers"] = [
-        t for t in triggers_config["triggers"] 
-        if t.get("id") != trigger_id
-    ]
-    
-    if len(triggers_config["triggers"]) < original_count:
-        save_triggers(brain_path, triggers_config)
-        return True
-    
-    return False

package/src/mcp_server_nucleus/runtime/vector_store.py

@@ -1,125 +0,0 @@
-
-import logging
-import time
-from typing import List, Dict, Any
-from .llm_client import DualEngineLLM
-from .storage import get_firestore_client, STORAGE_TYPE
-
-logger = logging.getLogger("nucleus.vector_store")
-
-class VectorStore:
-    """
-    Manages Vector Storage and Retrieval using Firestore and Gemini Embeddings.
-    """
-    def __init__(self):
-        # We use a separate collection for memory vectors to avoid polluting the 'brain' file system
-        self.collection_name = "nucleus_memory"
-        self.enabled = STORAGE_TYPE == "firestore"
-
-        if self.enabled:
-            # Only initialize LLM if we are actually going to use it (requires API Key)
-            self.llm = DualEngineLLM(model_name="text-embedding-004")
-        else:
-            self.llm = None
-            logger.warning("⚠️ VectorStore disabled: NUCLEUS_STORAGE_TYPE is not 'firestore'.")
-
-    def store_memory(self, content: str, metadata: Dict[str, Any] = None) -> str:
-        """
-        Embeds and stores a memory chunk.
-        Returns the Document ID.
-        """
-        if not self.enabled:
-            logger.info(f"Skipping memory storage (Local Mode): {content[:30]}...")
-            return "local_mock_id"
-
-        metadata = metadata or {}
-        
-        try:
-            # Generate Embedding
-            embedding_resp = self.llm.embed_content(content, task_type="retrieval_document")
-            vector = embedding_resp.get('embedding', [])
-            
-            if not vector:
-                raise ValueError("Failed to generate embedding")
-
-            # Store in Firestore
-            db = get_firestore_client()
-            doc_ref = db.collection(self.collection_name).document()
-            
-            payload = {
-                "content": content,
-                "embedding": vector,  # Firestore supports Vector types? Or just list of floats.
-                # Note: Pure Firestore vector search requires VectorValue. 
-                # For MVP with `google-cloud-firestore` standard client, we store as raw list 
-                # OR we need to use the specific Vector helper if available.
-                # Assuming standard list for now, checking underlying support.
-                # Wait, standard Firestore check:
-                # To use KNN, we need `Vector` class from `google.cloud.firestore_v1.vector`.
-                # Let's try to import it, or fallback.
-                "metadata": metadata,
-                "created_at": time.time()
-            }
-            
-            # Helper for Vector type if available
-            try:
-                from google.cloud.firestore_v1.vector import Vector
-                payload["embedding_vector"] = Vector(vector)
-            except ImportError:
-                 # Fallback/Older lib: Just store list, but search won't work efficiently without it.
-                 pass
-
-            doc_ref.set(payload)
-            logger.info(f"🧠 Stored memory {doc_ref.id}")
-            return doc_ref.id
-
-        except Exception as e:
-            logger.error(f"Failed to store memory: {e}")
-            raise
-
-    def search_memory(self, query: str, limit: int = 5) -> List[Dict[str, Any]]:
-        """
-        Semantic search for memories.
-        """
-        if not self.enabled:
-            return [{"content": "Memory disabled in local mode", "score": 0.0}]
-
-        try:
-            # Embed Query
-            embedding_resp = self.llm.embed_content(query, task_type="retrieval_query")
-            query_vector = embedding_resp.get('embedding', [])
-            
-            if not query_vector:
-                return []
-
-            db = get_firestore_client()
-            coll = db.collection(self.collection_name)
-            
-            # KNN Search
-            # Requres `google-cloud-firestore>=2.14.0`
-            from google.cloud.firestore_v1.vector import Vector
-            from google.cloud.firestore_v1.base_vector_query import DistanceMeasure
-
-            # Execute Vector Search
-            vector_query = coll.find_nearest(
-                vector_field="embedding_vector",
-                query_vector=Vector(query_vector),
-                distance_measure=DistanceMeasure.COSINE,
-                limit=limit
-            )
-            
-            results = []
-            docs = vector_query.get()
-            for doc in docs:
-                data = doc.to_dict()
-                results.append({
-                    "id": doc.id,
-                    "content": data.get("content"),
-                    "metadata": data.get("metadata"),
-                    "score": 0.0 # Firestore doesn't return score easily in v1, implying raw sort
-                })
-                
-            return results
-
-        except Exception as e:
-            logger.error(f"Memory search failed: {e}")
-            return []

package/src/mcp_server_nucleus/runtime/watcher.py

@@ -1,112 +0,0 @@
-
-"""
-Async File Watcher for Nucleus.
-Provides event-driven monitoring of Brain changes (directives, tasks).
-
-Strategic Role:
-- Moves Daemon from "Sleep Loop" to "Event Driven" (where possible).
-- Monitors `directives.md` for policy updates.
-- Monitors `task.md` for new commands.
-"""
-
-import asyncio
-import logging
-from pathlib import Path
-from typing import Callable, List, Dict
-
-logger = logging.getLogger(__name__)
-
-class AsyncFileWatcher:
-    def __init__(self, watch_paths: List[Path], callback: Callable, polling_interval: float = 2.0):
-        self.watch_paths = watch_paths
-        self.callback = callback
-        self.polling_interval = polling_interval
-        self.running = False
-        self._last_mtimes: Dict[Path, float] = {}
-        
-        # Try to import watchdog for native OS events, fallback to polling
-        self.use_watchdog = False
-        try:
-            from watchdog.observers import Observer
-            self.use_watchdog = True
-            self.observer = Observer()
-            self._handler = self._create_handler()
-        except ImportError:
-            logger.info("Watchdog not installed. Falling back to Polling.")
-
-    def _create_handler(self):
-        from watchdog.events import FileSystemEventHandler
-        
-        class Handler(FileSystemEventHandler):
-            def __init__(self, callback):
-                self.cb = callback
-                
-            def on_modified(self, event):
-                if not event.is_directory:
-                    # Debounce or just fire?
-                    # For V1, just fire. simple.
-                    asyncio.run_coroutine_threadsafe(self.cb(Path(event.src_path)), asyncio.get_running_loop())
-                    
-        return Handler(self.callback)
-
-    async def start(self):
-        """Start the watcher"""
-        self.running = True
-        
-        if self.use_watchdog:
-            logger.info("👀 Starting Native File Watcher (Watchdog)")
-            # Re-import to be safe or use what we confirmed
-            
-            # Watch valid directories
-            watched_dirs = set()
-            for p in self.watch_paths:
-                if p.exists():
-                    p_dir = p if p.is_dir() else p.parent
-                    if p_dir not in watched_dirs:
-                        self.observer.schedule(self._handler, str(p_dir), recursive=False)
-                        watched_dirs.add(p_dir)
-            
-            try:
-                self.observer.start()
-                # Watchdog runs in thread, we just await nothing or keep loop alive elsewhere
-            except Exception as e:
-                logger.error(f"Watchdog failed to start: {e}. Fallback to polling.")
-                self.use_watchdog = False
-                
-        if not self.use_watchdog:
-            logger.info(f"👀 Starting Polling Watcher ({self.polling_interval}s)")
-            asyncio.create_task(self._poll_loop())
-
-    async def _poll_loop(self):
-        """Robust polling loop"""
-        # Init mtimes
-        for p in self.watch_paths:
-            if p.exists():
-                self._last_mtimes[p] = p.stat().st_mtime
-                
-        while self.running:
-            for p in self.watch_paths:
-                if p.exists():
-                    try:
-                        current_mtime = p.stat().st_mtime
-                        last_mtime = self._last_mtimes.get(p)
-                        
-                        if last_mtime != current_mtime:
-                            self._last_mtimes[p] = current_mtime
-                            # Trigger callback
-                            logger.debug(f"File changed: {p.name}")
-                            if asyncio.iscoroutinefunction(self.callback):
-                                await self.callback(p)
-                            else:
-                                self.callback(p)
-                    except OSError:
-                        pass # File reading error, skip this tick
-            
-            await asyncio.sleep(self.polling_interval)
-
-    async def stop(self):
-        """Stop watching"""
-        self.running = False
-        if self.use_watchdog:
-            self.observer.stop()
-            self.observer.join()