nucleus-mcp 1.0.7 → 1.2.0

package/src/mcp_server_nucleus/runtime/broker.py

@@ -1,126 +0,0 @@
-"""
-ContextBroker: The Economy Engine.
-Facilitates the exchange of information (context) negotiation between agents.
-
-Roles:
-1. MARKETPLACE: Where agents list what they know.
-2. CLEARING HOUSE: Records transactions (who bought what).
-3. SETTLEMENT: (Future) Handles credit transfers.
-"""
-
-import json
-import logging
-import uuid
-from datetime import datetime
-from typing import List, Optional, Dict, Literal
-from pathlib import Path
-from pydantic import BaseModel
-
-from .locking import get_lock
-
-logger = logging.getLogger("BROKER")
-
-class ContextListing(BaseModel):
-    id: str
-    provider_id: str
-    topic: str
-    description: str
-    content: str # In MVP, content is stored directly. In prod, this is a pointer.
-    price: float = 0.0
-    type: Literal["data", "service"] = "data"
-    created_at: str
-
-class ContextTransaction(BaseModel):
-    id: str
-    listing_id: str
-    buyer_id: str
-    seller_id: str
-    amount: float
-    timestamp: str
-    content: Optional[str] = None # The delivered goods
-
-class ContextBroker:
-    def __init__(self, brain_path: Path):
-        self.brain_path = brain_path
-        self.listings_path = brain_path / "ledger" / "listings.json"
-        self.ledger_path = brain_path / "ledger" / "transactions.jsonl"
-        
-        # Ensure dirs
-        self.listings_path.parent.mkdir(parents=True, exist_ok=True)
-
-    def _load_listings(self) -> Dict[str, ContextListing]:
-        with get_lock("broker", self.brain_path).section():
-            if not self.listings_path.exists():
-                return {}
-            try:
-                data = json.loads(self.listings_path.read_text())
-                return {k: ContextListing(**v) for k, v in data.items()}
-            except Exception:
-                return {}
-
-    def _save_listings(self, listings: Dict[str, ContextListing]):
-        with get_lock("broker", self.brain_path).section():
-            data = {k: v.model_dump() for k, v in listings.items()}
-            self.listings_path.write_text(json.dumps(data, indent=2))
-
-    def publish_listing(self, provider_id: str, topic: str, description: str, content: str, price: float = 0.0, type: Literal["data", "service"] = "data") -> str:
-        """Create a new context listing."""
-        listing_id = f"list-{uuid.uuid4().hex[:8]}"
-        listing = ContextListing(
-            id=listing_id,
-            provider_id=provider_id,
-            topic=topic,
-            description=description,
-            content=content,
-            price=price,
-            type=type,
-            created_at=datetime.now().isoformat()
-        )
-        
-        listings = self._load_listings()
-        listings[listing_id] = listing
-        self._save_listings(listings)
-        
-        logger.info(f"📢 Listing Published: {topic} by {provider_id} ({listing_id})")
-        return listing_id
-
-    def search_listings(self, query: str) -> List[ContextListing]:
-        """Find listings by topic or description."""
-        listings = self._load_listings()
-        query = query.lower()
-        results = []
-        for lst in listings.values():
-            if query in lst.topic.lower() or query in lst.description.lower():
-                results.append(lst)
-        return results
-
-    def buy_context(self, buyer_id: str, listing_id: str) -> Optional[ContextTransaction]:
-        """Execute a context transaction."""
-        listings = self._load_listings()
-        
-        if listing_id not in listings:
-            logger.error(f"❌ Transaction Failed: Listing {listing_id} not found")
-            return None
-            
-        listing = listings[listing_id]
-        
-        # In a real economy, check budget here.
-        
-        tx_id = f"tx-{uuid.uuid4().hex[:8]}"
-        tx = ContextTransaction(
-            id=tx_id,
-            listing_id=listing.id,
-            buyer_id=buyer_id,
-            seller_id=listing.provider_id,
-            amount=listing.price,
-            timestamp=datetime.now().isoformat(),
-            content=listing.content # Deliver the goods
-        )
-        
-        # Append to ledger
-        with get_lock("ledger", self.brain_path).section():
-            with open(self.ledger_path, "a") as f:
-                f.write(tx.model_dump_json() + "\n")
-                
-        logger.info(f"💰 Sold: {listing.topic} from {listing.provider_id} to {buyer_id}")
-        return tx

package/src/mcp_server_nucleus/runtime/budget.py

@@ -1,153 +0,0 @@
-"""
-BudgetAuditor: The Financial Fuse.
-Strictly enforces spending limits for Nucleus operations.
-
-Strategic Role:
-- Tracks cumulative spend across sessions.
-- "Hard Fuse": Cuts off execution if budget exceeded.
-- Uses BrainLock for accurate accounting.
-- Supports Per-Agent BudgetGuard.
-"""
-
-import json
-import logging
-from datetime import datetime
-from pathlib import Path
-from typing import Dict, Any, List
-from .locking import get_lock
-from .capabilities.base import Capability
-
-logger = logging.getLogger("BUDGET_AUDITOR")
-
-class BudgetAuditor:
-    def __init__(self, brain_path: Path):
-        self.brain_path = brain_path
-        self.ledger_path = brain_path / "ledger" / "budget_ledger.json"
-        
-        # Ensure ledger dir exists
-        self.ledger_path.parent.mkdir(parents=True, exist_ok=True)
-        
-    def _load_ledger(self) -> Dict:
-        if self.ledger_path.exists():
-            try:
-                return json.loads(self.ledger_path.read_text())
-            except Exception:
-                pass
-        return {
-            "total_spend_usd": 0.0,
-            "daily_spend_usd": {}, # "YYYY-MM-DD": float
-            "agent_spend_usd": {}, # "str(agent_id)": float (Cumulative)
-            "transactions": []
-        }
-        
-    def _save_ledger(self, ledger: Dict):
-        self.ledger_path.write_text(json.dumps(ledger, indent=2))
-        
-    def check_authorization(self, completed_cost: float = 0.0) -> bool:
-        """
-        Global check (Not agent specific).
-        For now, just a placeholder or daily limit check.
-        """
-        return True
-
-    def record_expense(self, amount_usd: float, description: str, source: str = "llm"):
-        """Record a completed expense globally and per-agent"""
-        with get_lock("budget", self.brain_path).section():
-            ledger = self._load_ledger()
-            today = datetime.now().strftime("%Y-%m-%d")
-            
-            ledger["total_spend_usd"] += amount_usd
-            ledger["daily_spend_usd"][today] = ledger["daily_spend_usd"].get(today, 0.0) + amount_usd
-            
-            # If source is an agent ID, track per agent
-            if source:
-                 ledger["agent_spend_usd"][source] = ledger["agent_spend_usd"].get(source, 0.0) + amount_usd
-            
-            ledger["transactions"].append({
-                "timestamp": datetime.now().isoformat(),
-                "amount": amount_usd,
-                "description": description,
-                "source": source
-            })
-            
-            # Trim transactions if too long
-            if len(ledger["transactions"]) > 1000:
-                ledger["transactions"] = ledger["transactions"][-1000:]
-                
-            self._save_ledger(ledger)
-            
-    def get_agent_spend(self, agent_id: str) -> float:
-        """Get total spend for a specific agent"""
-        ledger = self._load_ledger()
-        return ledger.get("agent_spend_usd", {}).get(agent_id, 0.0)
-
-
-class BudgetGuard(Capability):
-    """
-    Wraps an imported capability to enforce strict budget limits for a specific agent.
-    "Host Policy overrides Agent Policy".
-    """
-    def __init__(self, inner: Capability, auditor: BudgetAuditor, agent_id: str, max_budget_usd: float = 0.0):
-        # Initialize Abstract Base Class
-        # Note: We don't call super().__init__() because ABCs don't need it, 
-        # but we must ensure we don't violate property requirements.
-        self.inner = inner
-        self.auditor = auditor
-        self.agent_id = agent_id
-        self.max_budget_usd = max_budget_usd
-        
-        # Load initial spend state
-        self.spent_usd = self.auditor.get_agent_spend(agent_id)
-
-    @property
-    def name(self) -> str:
-        return self.inner.name
-
-    @property
-    def description(self) -> str:
-        return f"{self.inner.description} (Budget: ${self.max_budget_usd})"
-
-    def get_tools(self) -> List[Dict[str, Any]]:
-        # We might want to wrap tool descriptions too, but for now we delegate
-        return self.inner.get_tools()
-        
-    def execute(self, params: Dict[str, Any]) -> str:
-        # Sync simple spending state (in case other tools updated it)
-        self.spent_usd = self.auditor.get_agent_spend(self.agent_id)
-
-        # 1. Pre-Check (Hard Fuse)
-        if self.spent_usd >= self.max_budget_usd and self.max_budget_usd >= 0: 
-            # Note: We can treat max_budget_usd < 0 as infinite if we wanted, 
-            # but for now let's say >=0 is required.
-            if self.max_budget_usd == 0:
-                 return "❌ SECURITY BLOCK: Zero Cost Budget Enforced."
-            
-            # Allow execution if we are extremely close (floating point epsilon) 
-            # OR if we want to strict block. Let's strict block.
-            return f"❌ SECURITY BLOCK: Budget Exceeded (${self.spent_usd:.4f}/${self.max_budget_usd:.2f})"
-            
-        # 2. Execute Inner Tool
-        logger.info(f"💰 BudgetGuard Allowing {self.agent_id} call (Spent: ${self.spent_usd})")
-        try:
-            result = self.inner.execute(params)
-        except Exception as e:
-            # Even if it fails, did it cost money? 
-            # For network tools/LLM, yes. For local function errors, maybe not.
-            # We assume "Attempted Execution" costs standard rate for now.
-             result = f"Error: {e}"
-
-        # 3. Post-Check (Record Cost)
-        # In a real system, we'd measure token usage or network bytes.
-        # For simulation/Phase 57, we assume a flat rate per tool call.
-        COST_PER_CALL = 0.01 
-        
-        self.auditor.record_expense(
-            amount_usd=COST_PER_CALL,
-            description=f"Action: {self.inner.name}",
-            source=self.agent_id
-        )
-        
-        # Update local tracking
-        self.spent_usd += COST_PER_CALL
-        
-        return result

package/src/mcp_server_nucleus/runtime/capabilities/base.py

@@ -1,20 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import List, Dict, Any
-
-class Capability(ABC):
-    @property
-    @abstractmethod
-    def name(self) -> str:
-        """Name of the capability cluster (e.g., 'render_ops')."""
-        pass
-
-    @property
-    @abstractmethod
-    def description(self) -> str:
-        """Description for the Context Factory."""
-        pass
-
-    @abstractmethod
-    def get_tools(self) -> List[Dict[str, Any]]:
-        """Return list of MCP tool definitions."""
-        pass

package/src/mcp_server_nucleus/runtime/capabilities/brain_ops.py

@@ -1,253 +0,0 @@
-from typing import List, Dict, Any
-from pathlib import Path
-import os
-from .base import Capability
-from ... import commitment_ledger
-
-class BrainOps(Capability):
-    @property
-    def name(self) -> str:
-        return "brain_ops"
-
-    @property
-    def description(self) -> str:
-        return "Tools for managing the centralized commitment ledger (The Brain)."
-
-    def get_tools(self) -> List[Dict[str, Any]]:
-        return [
-            {
-                "name": "brain_add_commitment",
-                "description": "Add a new commitment (task, todo, loop) to the ledger.",
-                "parameters": {
-                    "type": "object", 
-                    "properties": {
-                        "description": {"type": "string"},
-                        "loop_type": {"type": "string", "enum": ["task", "todo", "draft", "decision"]},
-                        "priority": {"type": "integer", "minimum": 1, "maximum": 5},
-                        "source": {"type": "string"}
-                    },
-                    "required": ["description"]
-                }
-            },
-            {
-                "name": "brain_get_open_loops",
-                "description": "Get all active open loops.",
-                "parameters": {
-                    "type": "object", 
-                    "properties": {
-                        "type_filter": {"type": "string"}
-                    }
-                }
-            },
-            {
-                "name": "brain_scan_commitments",
-                "description": "Trigger the Librarian to scan artifacts for checklist items.",
-                "parameters": {"type": "object", "properties": {}}
-            },
-            {
-                "name": "brain_archive_stale",
-                "description": "Trigger the Librarian to archive stale commitments.",
-                "parameters": {"type": "object", "properties": {}}
-            },
-            {
-                "name": "brain_orchestrate_swarm",
-                "description": "Initialize a multi-agent swarm for a complex mission.",
-                "parameters": {
-                    "type": "object", 
-                    "properties": {
-                        "mission": {"type": "string"},
-                        "agents": {"type": "array", "items": {"type": "string"}},
-                        "swarm_type": {"type": "string", "enum": ["genesis", "execution"]}
-                    },
-                    "required": ["mission"]
-                }
-            },
-            {
-                "name": "brain_export",
-                "description": "Export the brain content to a zip file (respecting .brainignore).",
-                "parameters": {"type": "object", "properties": {}}
-            },
-            {
-                "name": "brain_consolidate_logs",
-                "description": "Consolidate raw JSON logs in .brain/raw/ into a daily archive.",
-                "parameters": {"type": "object", "properties": {}}
-            },
-            {
-                "name": "brain_delegate_task",
-                "description": "Delegate a task to another specialized agent persona. The agent will execute autonomously.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "persona": {"type": "string", "description": "Target persona: librarian, researcher, critic, developer, architect, strategist, devops, synthesizer"},
-                        "intent": {"type": "string", "description": "The task description for the delegated agent"}
-                    },
-                    "required": ["persona", "intent"]
-                }
-            }
-        ]
-
-    def execute_tool(self, tool_name: str, args: Dict) -> str:
-        """Execute the tool locally using commitment_ledger."""
-        # Use configured brain path
-        brain_path = Path(os.environ.get("NUCLEUS_BRAIN_PATH", "/Users/lokeshgarg/ai-mvp-backend/.brain"))
-        
-        if tool_name == "brain_add_commitment":
-            result = commitment_ledger.add_commitment(
-                brain_path=brain_path,
-                source_file="NAR_AGENT",
-                source_line=0,
-                description=args['description'],
-                comm_type=args.get('loop_type', 'task'),
-                priority=args.get('priority', 3),
-                source=args.get('source', 'nar_agent')
-            )
-            return f"Commitment Added: {result['id']}"
-            
-        elif tool_name == "brain_get_open_loops":
-            loops = commitment_ledger.load_ledger(brain_path)["commitments"]
-            # Filter logic could go here
-            return f"Found {len([c for c in loops if c['status']=='open'])} open loops."
-            
-        elif tool_name == "brain_scan_commitments":
-            result = commitment_ledger.scan_for_commitments(brain_path)
-            return f"Scan Complete: {result}"
-            
-        elif tool_name == "brain_archive_stale":
-            count = commitment_ledger.auto_archive_stale(brain_path)
-            return f"Archived {count} stale items."
-            
-        elif tool_name == "brain_export":
-            # Call export logic (implemented in commitment_ledger for centralization)
-            if hasattr(commitment_ledger, 'export_brain'):
-                result = commitment_ledger.export_brain(brain_path)
-                return f"Export Complete: {result}"
-            return "Error: export_brain not implemented in ledger."
-
-        elif tool_name == "brain_delegate_task":
-             # Dynamic import to avoid circular dependency
-            from uuid import uuid4
-            from ..factory import ContextFactory
-            from ..agent import EphemeralAgent
-            from ..llm_client import DualEngineLLM
-            
-            persona = args.get('persona')
-            intent = args.get('intent')
-            
-            # Use factory to create specialized agent
-            session_id = f"delegated-{str(uuid4())[:8]}"
-            factory = ContextFactory()
-            
-            # Create context for the specific persona
-            context = factory.create_context_for_persona(session_id, persona, intent)
-            
-            # Execute
-            llm = DualEngineLLM()
-            agent = EphemeralAgent(context, model=llm)
-            
-            # In a real async environment, we'd await this. 
-            # But execute_tool is currently sync in this base class signature.
-            # We need to run it synchronously or change the signature.
-            # Using asyncio.run() for now as a bridge.
-            # Using asyncio.run() or existing loop via nest_asyncio
-            import asyncio
-            try:
-                import nest_asyncio
-                nest_asyncio.apply()
-            except ImportError:
-                pass
-
-            try:
-                # With nest_asyncio, we can just use asyncio.run or loop.run_until_complete
-                # even if a loop is running.
-                loop = asyncio.get_event_loop()
-                if loop.is_running():
-                    log = loop.run_until_complete(agent.run())
-                else:
-                    log = asyncio.run(agent.run())
-                
-                return f"✅ Delegation Complete:\n{log}"
-                
-            except RuntimeError:
-                # Fallback if nest_asyncio failed or not installed and loop is running
-                return f"⚠️ Cannot block on delegation (Async Loop Running & nest_asyncio missing). Task queued for {persona}: {intent}"
-
-        elif tool_name == "brain_orchestrate_swarm":
-            from ..orchestrator import SwarmsOrchestrator
-            import asyncio
-            
-            orchestrator = SwarmsOrchestrator(brain_path=brain_path)
-            
-            # Extract agents list from args
-            agents = args.get('agents', None)  # List of agent personas
-            
-            # start_mission is async, need to run it properly
-            try:
-                import nest_asyncio
-                nest_asyncio.apply()
-            except ImportError:
-                pass
-            
-            try:
-                loop = asyncio.get_event_loop()
-                if loop.is_running():
-                    result = loop.run_until_complete(orchestrator.start_mission(
-                        mission_goal=args['mission'],
-                        swarm_type=args.get('swarm_type', 'genesis'),
-                        agents=agents  # Pass agents to orchestrator
-                    ))
-                else:
-                    result = asyncio.run(orchestrator.start_mission(
-                        mission_goal=args['mission'],
-                        swarm_type=args.get('swarm_type', 'genesis'),
-                        agents=agents
-                    ))
-                
-                return f"✅ Swarm Initiated:\\nMission ID: {result.get('mission_id', 'unknown')}\\nAgents: {agents or 'auto-detected'}\\nStatus: {result.get('status', 'started')}"
-            except RuntimeError as e:
-                return f"⚠️ Swarm start failed (async issue): {e}. Mission queued."
-
-
-        elif tool_name == "brain_consolidate_logs":
-            # Consolidate raw logs into daily archives
-            import json
-            from datetime import datetime
-            
-            brain_path = Path(os.environ.get("NUCLEUS_BRAIN_PATH", "/Users/lokeshgarg/ai-mvp-backend/.brain"))
-            raw_path = brain_path / "raw"
-            archive_dir = brain_path / "archive"
-            archive_dir.mkdir(parents=True, exist_ok=True)
-            
-            if not raw_path.exists():
-                return "No raw logs to consolidate."
-                
-            logs = list(raw_path.glob("*.json"))
-            if not logs:
-                return "0 logs found. Nothing to consolidate."
-            
-            # Group by date
-            count = 0
-            size_saved = 0
-            
-            # Use current date for the archive bucket
-            # Ideally we group by the timestamp in the file, but for V1 just dumping current pile is fine.
-            today = datetime.now().strftime("%Y-%m-%d")
-            archive_file = archive_dir / f"raw_interactions_{today}.jsonl"
-            
-            with open(archive_file, "a") as out_f:
-                for log_file in logs:
-                    try:
-                         content = log_file.read_text()
-                         # Minify JSON line
-                         data = json.loads(content)
-                         out_f.write(json.dumps(data) + "\n")
-                         
-                         size_saved += log_file.stat().st_size
-                         log_file.unlink() # Delete original
-                         count += 1
-                    except Exception as e:
-                        print(f"Error consolidating {log_file}: {e}")
-                        
-            return f"✅ Consolidated {count} raw logs into {archive_file.name}. Saved {size_saved/1024:.2f} KB of inode space."
-
-        return f"Tool {tool_name} not found in BrainOps."
-