nucleus-mcp 1.0.7 → 1.2.0

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

@@ -1,205 +0,0 @@
-"""
-Nucleus Marketing Engine
-========================
-The Content Brain for GentleQuest.
-Auto-generates strategy and content from raw logs.
-
-Capabilities:
-- brain_synthesize_strategy: Reads marketing_log.md -> Updates strategy.md
-"""
-
-import os
-from pathlib import Path
-from typing import Dict, Optional
-import logging
-import time
-
-try:
-    from google import genai
-    HAS_GENAI = True
-except ImportError:
-    HAS_GENAI = False
-
-logger = logging.getLogger(__name__)
-
-# Constants
-MARKETING_LOG_PATH = "docs/marketing/marketing_log.md"
-STRATEGY_PATH = "docs/marketing/strategy.md"
-
-def _get_api_key() -> Optional[str]:
-    return os.environ.get("GEMINI_API_KEY")
-
-def brain_synthesize_strategy(
-    project_root: str,
-    focus_topic: Optional[str] = None
-) -> Dict[str, str]:
-    """
-    Analyze marketing logs and update the strategy document.
-    
-    Args:
-        project_root: Absolute path to project root
-        focus_topic: Optional specific topic to focus on
-        
-    Returns:
-        Dict with status and path to updated strategy
-    """
-    if not HAS_GENAI:
-        return {"status": "error", "message": "google-genai library not installed"}
-        
-    api_key = _get_api_key()
-    if not api_key:
-        return {"status": "error", "message": "GEMINI_API_KEY not found in environment"}
-        
-    root_path = Path(project_root)
-    log_path = root_path / MARKETING_LOG_PATH
-    strategy_path = root_path / STRATEGY_PATH
-    
-    if not log_path.exists():
-        return {"status": "error", "message": f"Log file not found at {log_path}"}
-        
-    # Read the log
-    with open(log_path, 'r') as f:
-        log_content = f.read()
-        
-    # Read existing strategy if valid
-    existing_strategy = ""
-    if strategy_path.exists():
-        with open(strategy_path, 'r') as f:
-            existing_strategy = f.read()
-
-    # Construct Prompt
-    prompt = f"""
-    You are the Chief Strategy Officer for GentleQuest (an AI mental health app for developers).
-    
-    TASK:
-    Analyze the daily marketing log and update the High-Level Strategy.
-    
-    INPUT DATA (Marketing Log):
-    {log_content[-2000:]}  # Last 2000 chars for context
-    
-    EXISTING STRATEGY:
-    {existing_strategy}
-    
-    INSTRUCTIONS:
-    1. Identify 'Rising Trends' and 'High Engagement' items from the log.
-    2. Synthesize them into concrete strategic 'Angles' (e.g., "Pivot to Anti-Streak messaging").
-    3. Output the FULL content for the new 'strategy.md' file.
-    4. Keep it concise, actionable, and formatted in Markdown.
-    5. Include a 'Recent Insights' section based on the logs.
-    
-    OUTPUT FORMAT:
-    (Markdown only)
-    """
-    
-    try:
-        client = genai.Client(api_key=api_key)
-        response = client.models.generate_content(
-            model="gemini-2.0-flash-exp",
-            contents=prompt
-        )
-        
-        new_strategy = response.text
-        
-        # Write to file
-        strategy_path.parent.mkdir(parents=True, exist_ok=True)
-        with open(strategy_path, 'w') as f:
-            f.write(new_strategy)
-            
-    except Exception as e:
-        logger.error(f"GenAI Strategy Synthesis failed: {e}")
-        return {"status": "error", "message": str(e)}
-
-def brain_optimize_workflow(
-    project_root: str
-) -> Dict[str, str]:
-    """
-    Scan marketing logs for 'META-FEEDBACK' and suggest workflow improvements.
-    
-    Args:
-        project_root: Absolute path to project root
-        
-    Returns:
-        Dict with status and suggestions
-    """
-    if not HAS_GENAI:
-        return {"status": "error", "message": "google-genai library not installed"}
-        
-    api_key = _get_api_key()
-    if not api_key:
-        return {"status": "error", "message": "GEMINI_API_KEY not found"}
-        
-    root_path = Path(project_root)
-    log_path = root_path / MARKETING_LOG_PATH
-    cheatsheet_path = root_path / ".agent/workflows/marketing_autopilot_cheatsheet.md"
-    
-    if not log_path.exists():
-        return {"status": "error", "message": "Log file not found"}
-
-    with open(log_path, 'r') as f:
-        log_content = f.read()
-        
-    # Check if there is any meta-feedback
-    if "META-FEEDBACK" not in log_content:
-        return {"status": "skipped", "message": "No META-FEEDBACK found in logs."}
-        
-    # Read existing cheatsheet for context
-    current_cheatsheet = ""
-    if cheatsheet_path.exists():
-        with open(cheatsheet_path, 'r') as f:
-            current_cheatsheet = f.read()
-
-    prompt = f"""
-    You are the 'Process Optimizer' for the Marketing Autopilot.
-    
-    INPUT DATA:
-    1. Marketing Log (Looking for 'META-FEEDBACK' tags):
-    {log_content[-5000:]}
-    
-    2. Current Cheatsheet (The Rules):
-    {current_cheatsheet}
-    
-    TASK:
-    1. Extract all 'META-FEEDBACK' suggestions from the log.
-    2. Analyze if the Cheatsheet needs updating.
-    3. Generate a list of actionable tasks for 'task.md'.
-    
-    OUTPUT FORMAT:
-    (Markdown Checklist Items Only)
-    - [ ] Update Cheatsheet: [Specific Prompt Change]
-    - [ ] Fix Dashboard UI: [Specific Bug]
-    """
-    
-    try:
-        client = genai.Client(api_key=api_key)
-        response = client.models.generate_content(
-            model="gemini-2.0-flash-exp",
-            contents=prompt
-        )
-        
-        new_tasks = response.text
-        
-        # Determine where to write tasks
-        # Plan A: Try to find the specific conversation task.md (This is hard from here without context)
-        # Plan B: Write to the Central Ledger (V2) or a dedicated improvements file
-        
-        # We'll use a dedicated file for Workflow Improvements that the Human can triage
-        # This avoids messing up specific task.lhs if IDs change
-        improvement_path = root_path / ".brain/ledger/WORKFLOW_IMPROVEMENTS.md"
-        improvement_path.parent.mkdir(parents=True, exist_ok=True)
-        
-        # If the file exists, append. If not, create.
-        mode = 'a' if improvement_path.exists() else 'w'
-        with open(improvement_path, mode) as f:
-            timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
-            f.write(f"\n\n## 🧬 Workflow Upgrades (Auto-Generated {timestamp})\n{new_tasks}")
-            
-        return {
-            "status": "success",
-            "message": "Optimization tasks generated in WORKFLOW_IMPROVEMENTS.md",
-            "path": str(improvement_path)
-        }
-        
-    except Exception as e:
-        logger.error(f"Workflow Optimization failed: {e}")
-        return {"status": "error", "message": str(e)}
-

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

@@ -1,79 +0,0 @@
-
-from typing import List, Dict, Any
-from .base import Capability
-from ..vector_store import VectorStore
-
-class MemoryOps(Capability):
-    """Capability for Long-term Memory Access (RAG)"""
-    
-    def __init__(self):
-        self.vector_store = VectorStore()
-    
-    @property
-    def name(self) -> str:
-        return "memory_ops"
-
-    @property
-    def description(self) -> str:
-        return "Tools for accessing and searching long-term memory (RAG)."
-        
-    def get_tools(self) -> List[Dict]:
-        return [
-            {
-                "name": "brain_store_memory",
-                "description": "Store a text chunk in long-term memory with metadata.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "content": {"type": "string", "description": "The text content to remember"},
-                        "category": {"type": "string", "description": "Category (e.g., learning, preference, fact)"},
-                        "source": {"type": "string", "description": "Source of info (e.g., session_id, user)"},
-                        "tags": {"type": "array", "items": {"type": "string"}, "description": "Optional tags"}
-                    },
-                    "required": ["content"]
-                }
-            },
-            {
-                "name": "brain_search_memory",
-                "description": "Semantic search for relevant memories.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "query": {"type": "string", "description": "Search query"},
-                        "limit": {"type": "integer", "description": "Max results (default 5)"}
-                    },
-                    "required": ["query"]
-                }
-            }
-        ]
-
-    def execute_tool(self, tool_name: str, args: Dict) -> Any:
-        try:
-            if tool_name == "brain_store_memory":
-                metadata = {
-                    "category": args.get("category", "general"),
-                    "source": args.get("source", "agent"),
-                    "tags": args.get("tags", [])
-                }
-                doc_id = self.vector_store.store_memory(args["content"], metadata)
-                return f"Stored memory: {doc_id}"
-                
-            elif tool_name == "brain_search_memory":
-                results = self.vector_store.search_memory(
-                    query=args["query"], 
-                    limit=args.get("limit", 5)
-                )
-                if not results:
-                    return "No matching memories found."
-                
-                # Format for LLM consumption
-                formatted = []
-                for r in results:
-                    meta = r.get("metadata", {})
-                    formatted.append(f"- [{meta.get('category', 'gen')}] {r['content']}")
-                
-                return "\n".join(formatted)
-
-            return f"Tool {tool_name} not found"
-        except Exception as e:
-            return f"Error executing {tool_name}: {str(e)}"

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

@@ -1,127 +0,0 @@
-from typing import List, Dict, Any
-import os
-import time
-from pathlib import Path
-from .base import Capability
-
-class ProofSystem(Capability):
-    def __init__(self):
-        # Determine brain path
-        brain_path_str = os.environ.get("NUCLEAR_BRAIN_PATH")
-        if not brain_path_str:
-            brain_path_str = "/Users/lokeshgarg/.gemini/antigravity/brain/7c654df4-b83e-43f9-8620-f15868ec39d1"
-            
-        self.brain_path = Path(brain_path_str)
-        self.proofs_dir = self.brain_path / "features" / "proofs"
-        self.proofs_dir.mkdir(parents=True, exist_ok=True)
-    
-    @property
-    def name(self) -> str:
-        return "proof_system"
-
-    @property
-    def description(self) -> str:
-        return "Generates tangible evidence of work (proofs) to build trust and transparency."
-
-    def get_tools(self) -> List[Dict[str, Any]]:
-        return [
-            {
-                "name": "brain_generate_proof",
-                "description": "Generate a markdown proof document for a feature.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "feature_id": {"type": "string", "description": "Feature to generate proof for"},
-                        "thinking": {"type": "string", "description": "AI's decision-making process (markdown)"},
-                        "deployed_url": {"type": "string", "description": "Production URL"},
-                        "files_changed": {"type": "array", "items": {"type": "string"}, "description": "List of files modified"},
-                        "risk_level": {"type": "string", "description": "low/medium/high"},
-                        "rollback_time": {"type": "string", "description": "Estimated time to rollback"}
-                    },
-                    "required": ["feature_id"]
-                }
-            },
-            {
-                "name": "brain_get_proof",
-                "description": "Get the proof document for a feature.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "feature_id": {"type": "string", "description": "Feature ID to get proof for"}
-                    },
-                    "required": ["feature_id"]
-                }
-            },
-            {
-                "name": "brain_list_proofs",
-                "description": "List all proof documents.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {}
-                }
-            }
-        ]
-
-    def execute_tool(self, tool_name: str, args: Dict) -> Any:
-        try:
-            if tool_name == "brain_generate_proof":
-                return self._generate_proof(args)
-            elif tool_name == "brain_get_proof":
-                return self._get_proof(args.get("feature_id"))
-            elif tool_name == "brain_list_proofs":
-                return self._list_proofs()
-            return f"Tool {tool_name} not found"
-        except Exception as e:
-            return f"Error executing {tool_name}: {str(e)}"
-
-    def _generate_proof(self, args: Dict) -> Dict:
-        feature_id = args.get("feature_id")
-        thinking = args.get("thinking", "No thinking provided.")
-        deployed_url = args.get("deployed_url", "N/A")
-        files_changed = args.get("files_changed", [])
-        risk_level = args.get("risk_level", "low")
-        rollback_time = args.get("rollback_time", "Unknown")
-        
-        # Format the proof markdown (Tier 1 Style)
-        timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
-        
-        files_block = "\n".join([f"- {f}" for f in files_changed]) if files_changed else "None"
-        
-        content = f"""# Proof: {feature_id}
-
-> Generated: {timestamp}
-
-## Thinking
-{thinking}
-
-## Deployed URL
-{deployed_url}
-
-## Files Changed
-{files_block}
-
-## Rollback Plan
-- **Risk Level:** {risk_level.upper()}
-- **Estimated Time:** {rollback_time}
-- **Strategy:** `git revert` or restore from backup.
-"""
-        
-        file_path = self.proofs_dir / f"{feature_id}.md"
-        file_path.write_text(content)
-        
-        return {
-            "success": True,
-            "message": f"Proof generated for {feature_id}",
-            "path": str(file_path)
-        }
-
-    def _get_proof(self, feature_id: str) -> str:
-        file_path = self.proofs_dir / f"{feature_id}.md"
-        if not file_path.exists():
-            return f"Proof for {feature_id} not found."
-        return file_path.read_text()
-
-    def _list_proofs(self) -> List[str]:
-        if not self.proofs_dir.exists():
-            return []
-        return [p.name for p in self.proofs_dir.glob("*.md")]

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

@@ -1,80 +0,0 @@
-from typing import List, Dict, Any
-import os
-import json
-import urllib.request
-import urllib.error
-from .base import Capability
-
-class RenderOps(Capability):
-    def __init__(self):
-        self.api_key = os.environ.get("RENDER_API_KEY")
-        self.base_url = "https://api.render.com/v1"
-
-    @property
-    def name(self) -> str:
-        return "render_ops"
-
-    @property
-    def description(self) -> str:
-        return "Tools for interacting with the Render.com API (Deployments, Services)."
-
-    def get_tools(self) -> List[Dict[str, Any]]:
-        return [
-            {
-                "name": "render_list_services",
-                "description": "List all services in Render account.",
-                "parameters": {"type": "object", "properties": {}}
-            },
-            {
-                "name": "render_deploy_service",
-                "description": "Trigger a deployment for a specific service.",
-                "parameters": {
-                    "type": "object", 
-                    "properties": {
-                        "service_id": {"type": "string"}
-                    },
-                    "required": ["service_id"]
-                }
-            }
-        ]
-
-    def execute_tool(self, tool_name: str, args: Dict) -> str:
-        if not self.api_key:
-            return "Error: RENDER_API_KEY not found in environment."
-
-        headers = {
-            "Authorization": f"Bearer {self.api_key}",
-            "Content-Type": "application/json",
-            "Accept": "application/json"
-        }
-
-        try:
-            if tool_name == "render_list_services":
-                url = f"{self.base_url}/services?limit=20"
-                req = urllib.request.Request(url, headers=headers)
-                
-                with urllib.request.urlopen(req) as response:
-                    if response.status == 200:
-                        data = json.load(response)
-                        services = [f"{s['service']['name']} ({s['service']['id']})" for s in data]
-                        return "Services:\n" + "\n".join(services)
-                    return f"Error listing services: HTTP {response.status}"
-
-            elif tool_name == "render_deploy_service":
-                sid = args.get('service_id')
-                url = f"{self.base_url}/services/{sid}/deploys"
-                data = json.dumps({"clearCache": "clear"}).encode('utf-8')
-                req = urllib.request.Request(url, data=data, headers=headers, method="POST")
-                
-                with urllib.request.urlopen(req) as response:
-                    if response.status == 201:
-                        deploy = json.load(response)
-                        return f"Deployment triggered: {deploy['id']}"
-                    return f"Error triggering deploy: HTTP {response.status}"
-
-        except urllib.error.HTTPError as e:
-            return f"Render API Error ({e.code}): {e.read().decode('utf-8')}"
-        except Exception as e:
-            return f"Exception calling Render API: {e}"
-
-        return f"Tool {tool_name} not found in RenderOps."