nucleus-mcp 1.0.7 → 1.2.0

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

@@ -1,192 +0,0 @@
-from typing import List, Dict, Any
-import os
-import subprocess
-from pathlib import Path
-from .base import Capability
-
-class CodeOps(Capability):
-    @property
-    def name(self) -> str:
-        return "code_ops"
-
-    @property
-    def description(self) -> str:
-        return "FileSystem and Shell Access for Coding Agents."
-
-    def get_tools(self) -> List[Dict[str, Any]]:
-        return [
-            {
-                "name": "code_read_file",
-                "description": "Read file contents.",
-                "parameters": {
-                    "type": "object", 
-                    "properties": {
-                        "path": {"type": "string", "description": "Absolute or relative path"}
-                    },
-                    "required": ["path"]
-                }
-            },
-            {
-                "name": "code_write_file",
-                "description": "Write or overwrite file contents. Creates directories if needed.",
-                "parameters": {
-                    "type": "object", 
-                    "properties": {
-                        "path": {"type": "string", "description": "Absolute or relative path"},
-                        "content": {"type": "string"}
-                    },
-                    "required": ["path", "content"]
-                }
-            },
-            {
-                "name": "code_run_command",
-                "description": "Execute a shell command.",
-                "parameters": {
-                    "type": "object", 
-                    "properties": {
-                        "command": {"type": "string"},
-                        "timeout": {"type": "integer", "default": 30}
-                    },
-                    "required": ["command"]
-                }
-            },
-            {
-                "name": "code_list_files",
-                "description": "List files in directory.",
-                "parameters": {
-                    "type": "object", 
-                    "properties": {
-                        "path": {"type": "string", "default": "."}
-                    }
-                }
-            }
-        ]
-
-    def _resolve_path(self, path_str: str) -> Path:
-        """
-        Self-Healing Path Resolver.
-        """
-        cwd = Path(os.getcwd())
-        path = Path(path_str)
-        
-        # 1. Try path as-is
-        if path.exists():
-            return path
-            
-        # 2. Try relative to CWD
-        if not path.is_absolute():
-            candidate = cwd / path
-            if candidate.exists():
-                return candidate
-        
-        # 3. Try relative to Project Root (BRAIN_PATH.parent)
-        brain_path = Path(os.environ.get("NUCLEUS_BRAIN_PATH", "/Users/lokeshgarg/ai-mvp-backend/.brain"))
-        project_root = brain_path.parent
-        
-        if not path.is_absolute():
-            candidate = project_root / path
-            if candidate.exists():
-                return candidate
-        else:
-            # If absolute but invalid, try re-rooting
-            # e.g. /gentlequest-blog/... -> PROJECT_ROOT/gentlequest-blog/...
-            if 'ai-mvp-backend' in path_str:
-                relative = path_str.split('ai-mvp-backend')[-1].lstrip('/')
-                candidate = project_root / relative
-                if candidate.exists():
-                    return candidate
-            else:
-                # Try just the relative part of the absolute path
-                # e.g. /foo/bar -> PROJECT_ROOT/foo/bar
-                relative = path_str.lstrip('/')
-                candidate = project_root / relative
-                if candidate.exists():
-                    return candidate
-
-        return path
-
-    def execute_tool(self, tool_name: str, args: Dict) -> str:
-        """Execute local filesystem/shell operations."""
-        cwd = os.getcwd()
-        
-        if tool_name == "code_read_file":
-            path = self._resolve_path(args['path'])
-            
-            if not path.exists():
-                return f"Error: File not found: {path} (in {cwd})"
-            return path.read_text(encoding='utf-8')
-            
-        elif tool_name == "code_write_file":
-            path_str = args['path']
-            path = Path(path_str)
-            
-            # ============================================================
-            # ENTERPRISE PATH RESOLUTION (Fix for Read-Only Filesystem Bug)
-            # ============================================================
-            # Problem: Agent subprocess may not have NUCLEUS_BRAIN_PATH set,
-            # causing relative paths like 'gentlequest-blog/...' to resolve to '/'
-            # Solution: Robust fallback chain with explicit validation
-            
-            PROJECT_ROOT = Path("/Users/lokeshgarg/ai-mvp-backend")
-            
-            if not path.is_absolute():
-                resolved_root = None
-                
-                # Option 1: Use NUCLEUS_BRAIN_PATH if valid
-                brain_path_str = os.environ.get("NUCLEUS_BRAIN_PATH", "")
-                if brain_path_str and ".brain" in brain_path_str:
-                    brain_path = Path(brain_path_str)
-                    if brain_path.exists():
-                        resolved_root = brain_path.parent
-                
-                # Option 2: Fallback to hardcoded PROJECT_ROOT
-                if not resolved_root:
-                    resolved_root = PROJECT_ROOT
-                
-                path = resolved_root / path
-                # Log resolution for debugging
-                print(f"[CodeOps] Path resolved: {path_str} → {path}")
-            
-            # Ensure parent directory exists
-            path.parent.mkdir(parents=True, exist_ok=True)
-            path.write_text(args['content'], encoding='utf-8')
-            return f"✅ Wrote {len(args['content'])} bytes to {path}"
-
-            
-        elif tool_name == "code_run_command":
-            cmd = args['command']
-            timeout = args.get('timeout', 30)
-            try:
-                result = subprocess.run(
-                    cmd, 
-                    shell=True, 
-                    capture_output=True, 
-                    text=True, 
-                    cwd=cwd, 
-                    timeout=timeout
-                )
-                return f"Exit Code: {result.returncode}\nstdout:\n{result.stdout}\nstderr:\n{result.stderr}"
-            except subprocess.TimeoutExpired:
-                return f"Error: Command timed out after {timeout}s"
-            except Exception as e:
-                return f"Error: {str(e)}"
-
-        elif tool_name == "code_list_files":
-            path = Path(args.get('path', '.'))
-            if not path.is_absolute():
-                path = Path(cwd) / path
-            
-            if not path.exists():
-                 return f"Error: Path not found: {path}"
-                 
-            try:
-                # Use 'ls -F' style output for simplicity
-                entries = []
-                for p in path.iterdir():
-                    kind = "/" if p.is_dir() else ""
-                    entries.append(f"{p.name}{kind}")
-                return "\n".join(sorted(entries))
-            except Exception as e:
-                return f"Error listing files: {str(e)}"
-                
-        return f"Tool {tool_name} not found in CodeOps."

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

@@ -1,81 +0,0 @@
-from typing import List, Dict, Any
-import os
-from .base import Capability
-# Import core logic from top-level package
-# Import core logic lazily inside methods to avoid circular dependency
-# from ... import _depth_push, _depth_pop, _depth_show, _depth_reset
-
-class DepthTracker(Capability):
-    def __init__(self):
-        # Determine brain path (fallback for agent runtime if env not set)
-        if not os.environ.get("NUCLEAR_BRAIN_PATH"):
-            # Default used in verification/dev
-            os.environ["NUCLEAR_BRAIN_PATH"] = "/Users/lokeshgarg/.gemini/antigravity/brain/7c654df4-b83e-43f9-8620-f15868ec39d1"
-
-    @property
-    def name(self) -> str:
-        return "depth_tracker"
-
-    @property
-    def description(self) -> str:
-        return "Tools for tracking conversation depth and preventing rabbit holes."
-
-    def get_tools(self) -> List[Dict[str, Any]]:
-        return [
-            {
-                "name": "brain_depth_push",
-                "description": "Go deeper into a subtopic. Tracks position in conversation tree.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "topic": {"type": "string", "description": "What you're diving into"}
-                    },
-                    "required": ["topic"]
-                }
-            },
-            {
-                "name": "brain_depth_pop",
-                "description": "Come back up one level in the conversation tree.",
-                "parameters": {"type": "object", "properties": {}}
-            },
-            {
-                "name": "brain_depth_show",
-                "description": "Show current depth state with visual indicator and tree.",
-                "parameters": {"type": "object", "properties": {}}
-            },
-            {
-                "name": "brain_depth_reset",
-                "description": "Reset depth to root level (0). Clears all levels.",
-                "parameters": {"type": "object", "properties": {}}
-            }
-        ]
-
-    def execute_tool(self, tool_name: str, args: Dict) -> str:
-        # Lazy import to avoid circular dependency
-        from ... import _depth_push, _depth_pop, _depth_show, _depth_reset
-
-        if tool_name == "brain_depth_push":
-            result = _depth_push(args.get("topic"))
-            if "error" in result:
-                return f"Error: {result['error']}"
-            return f"Descended to Level {result.get('current_depth')}: '{result.get('topic')}'.\n{result.get('warning', '')}\n{result.get('indicator')}"
-            
-        elif tool_name == "brain_depth_pop":
-            result = _depth_pop()
-            if "error" in result:
-                return f"Error: {result['error']}"
-            return f"{result.get('message')}\n{result.get('indicator')}"
-
-        elif tool_name == "brain_depth_show":
-            result = _depth_show()
-            if "error" in result:
-                return f"Error: {result['error']}"
-            return f"{result.get('indicator')}\nStatus: {result.get('status')}\nPath: {result.get('breadcrumbs')}\n\n{result.get('tree')}"
-
-        elif tool_name == "brain_depth_reset":
-            result = _depth_reset()
-            if "error" in result:
-                return f"Error: {result['error']}"
-            return result.get('message', 'Reset complete')
-
-        return f"Tool {tool_name} not found in DepthTracker."

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

@@ -1,274 +0,0 @@
-from typing import List, Dict, Any, Optional
-import json
-import os
-import time
-from pathlib import Path
-from .base import Capability
-
-class FeatureMap(Capability):
-    def __init__(self):
-        # Determine brain path
-        brain_path_str = os.environ.get("NUCLEAR_BRAIN_PATH")
-        if not brain_path_str:
-            # Fallback for dev/verification if not set (though highly recommended)
-            brain_path_str = "/Users/lokeshgarg/.gemini/antigravity/brain/7c654df4-b83e-43f9-8620-f15868ec39d1"
-            
-        self.brain_path = Path(brain_path_str)
-        self.features_dir = self.brain_path / "features"
-    
-    @property
-    def name(self) -> str:
-        return "feature_map"
-
-    @property
-    def description(self) -> str:
-        return "Manage the feature inventory to prevent 'feature amnesia'. Track what exists, status, and how to test."
-
-    def get_tools(self) -> List[Dict[str, Any]]:
-        return [
-            {
-                "name": "brain_add_feature",
-                "description": "Add a new feature to the product's feature map.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "product": {"type": "string", "description": "'gentlequest' or 'nucleus'"},
-                        "name": {"type": "string", "description": "Human-readable feature name"},
-                        "description": {"type": "string", "description": "What the feature does"},
-                        "source": {"type": "string", "description": "Where it lives (e.g., 'gentlequest_app', 'pypi_mcp')"},
-                        "version": {"type": "string", "description": "Which version it shipped in"},
-                        "status": {"type": "string", "description": "development/staged/production/released"},
-                        "how_to_test": {"type": "array", "items": {"type": "string"}, "description": "List of test steps"},
-                        "expected_result": {"type": "string", "description": "What should happen when testing"},
-                        "tags": {"type": "array", "items": {"type": "string"}, "description": "Searchable tags"}
-                    },
-                    "required": ["product", "name", "description", "source", "version", "how_to_test", "expected_result"]
-                }
-            },
-            {
-                "name": "brain_list_features",
-                "description": "List all features, optionally filtered.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "product": {"type": "string", "description": "Filter by product"},
-                        "status": {"type": "string", "description": "Filter by status"},
-                        "tag": {"type": "string", "description": "Filter by tag"}
-                    }
-                }
-            },
-            {
-                "name": "brain_get_feature",
-                "description": "Get a specific feature by ID.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "feature_id": {"type": "string", "description": "The feature ID (snake_case)"}
-                    },
-                    "required": ["feature_id"]
-                }
-            },
-            {
-                "name": "brain_update_feature",
-                "description": "Update a feature's fields.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "feature_id": {"type": "string", "description": "Feature to update"},
-                        "status": {"type": "string", "description": "New status"},
-                        "description": {"type": "string", "description": "New description"},
-                        "version": {"type": "string", "description": "New version"}
-                    },
-                    "required": ["feature_id"]
-                }
-            },
-            {
-                "name": "brain_mark_validated",
-                "description": "Mark a feature as validated after testing.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "feature_id": {"type": "string", "description": "Feature that was tested"},
-                        "result": {"type": "string", "description": "'passed' or 'failed'"}
-                    },
-                    "required": ["feature_id", "result"]
-                }
-            },
-            {
-                "name": "brain_search_features",
-                "description": "Search features by name, description, or tags.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "query": {"type": "string", "description": "Search query"}
-                    },
-                    "required": ["query"]
-                }
-            }
-        ]
-
-    def execute_tool(self, tool_name: str, args: Dict) -> Any:
-        try:
-            if tool_name == "brain_add_feature":
-                return self._add_feature(args)
-            elif tool_name == "brain_list_features":
-                return self._list_features(args)
-            elif tool_name == "brain_get_feature":
-                return self._get_feature(args.get("feature_id"))
-            elif tool_name == "brain_update_feature":
-                return self._update_feature(args)
-            elif tool_name == "brain_mark_validated":
-                return self._mark_validated(args.get("feature_id"), args.get("result"))
-            elif tool_name == "brain_search_features":
-                return self._search_features(args.get("query"))
-            return f"Tool {tool_name} not found"
-        except Exception as e:
-            return f"Error executing {tool_name}: {str(e)}"
-
-    # --- Internal Helpers ---
-
-    def _get_store_path(self, product: str) -> Path:
-        return self.features_dir / f"{product}.json"
-
-    def _load_store(self, product: str) -> Dict:
-        path = self._get_store_path(product)
-        if not path.exists():
-            return {"product": product, "features": []}
-        try:
-            return json.loads(path.read_text())
-        except Exception:
-            return {"product": product, "features": []}
-
-    def _save_store(self, product: str, data: Dict):
-        path = self._get_store_path(product)
-        # atomic write
-        path.parent.mkdir(parents=True, exist_ok=True)
-        path.write_text(json.dumps(data, indent=2))
-
-    def _generate_id(self, name: str) -> str:
-        # Simple snake_case conversion
-        return name.lower().replace(" ", "_").replace("-", "_")
-
-    # --- Core Logic ---
-
-    def _add_feature(self, args: Dict) -> Dict:
-        product = args.get("product").lower()
-        if product not in ["gentlequest", "nucleus"]:
-            # Default to gentlequest if unknown product? 
-            # Or enforce schema. Let's strictly enforce supported products for MVP
-            if product not in ["gentlequest", "nucleus"]:
-                 # Just treat it as a new product file
-                 pass
-        
-        store = self._load_store(product)
-        
-        feature_id = self._generate_id(args.get("name"))
-        
-        # Check if exists
-        for f in store["features"]:
-            if f["id"] == feature_id:
-                return {"error": f"Feature '{feature_id}' already exists. Use update."}
-
-        new_feature = {
-            "id": feature_id,
-            "name": args.get("name"),
-            "description": args.get("description"),
-            "product": product,
-            "source": args.get("source"),
-            "version": args.get("version"),
-            "status": args.get("status", "development"),
-            "how_to_test": args.get("how_to_test", []),
-            "expected_result": args.get("expected_result", ""),
-            "tags": args.get("tags", []),
-            "created_at": time.strftime("%Y-%m-%dT%H:%M:%S%z"),
-            "last_validated": None,
-            "validation_result": None
-        }
-
-        store["features"].append(new_feature)
-        store["total_features"] = len(store["features"])
-        store["last_updated"] = time.strftime("%Y-%m-%dT%H:%M:%S%z")
-        
-        self._save_store(product, store)
-        return {"success": True, "feature": new_feature}
-
-    def _list_features(self, args: Dict) -> List[Dict]:
-        products = ["gentlequest", "nucleus"]
-        target_product = args.get("product")
-        if target_product:
-            products = [target_product]
-        
-        all_features = []
-        for p in products:
-            store = self._load_store(p)
-            all_features.extend(store.get("features", []))
-            
-        # Filters
-        status = args.get("status")
-        tag = args.get("tag")
-        
-        if status:
-            all_features = [f for f in all_features if f.get("status") == status]
-        if tag:
-            all_features = [f for f in all_features if tag in f.get("tags", [])]
-            
-        return all_features[:50] # Limit output
-
-    def _get_find_feature(self, feature_id: str) -> Optional[Dict]:
-        # Helper to search across all products
-        for p in ["gentlequest", "nucleus"]:
-            store = self._load_store(p)
-            for f in store.get("features", []):
-                if f["id"] == feature_id:
-                    return f, p, store
-        return None, None, None
-
-    def _get_feature(self, feature_id: str) -> Any:
-        f, _, _ = self._get_find_feature(feature_id)
-        if f:
-            return f
-        return {"error": f"Feature '{feature_id}' not found"}
-
-    def _update_feature(self, args: Dict) -> Any:
-        feature_id = args.get("feature_id")
-        f, product, store = self._get_find_feature(feature_id)
-        
-        if not f:
-            return {"error": f"Feature '{feature_id}' not found"}
-            
-        # Update fields
-        valid_updates = ["status", "description", "version"]
-        updated = False
-        for key in valid_updates:
-            if key in args:
-                f[key] = args[key]
-                updated = True
-                
-        if updated:
-            self._save_store(product, store)
-            return {"success": True, "feature": f}
-        return {"success": False, "message": "No changes made"}
-
-    def _mark_validated(self, feature_id: str, result: str) -> Any:
-        f, product, store = self._get_find_feature(feature_id)
-        if not f:
-            return {"error": f"Feature '{feature_id}' not found"}
-            
-        f["last_validated"] = time.strftime("%Y-%m-%dT%H:%M:%S%z")
-        f["validation_result"] = result
-        
-        self._save_store(product, store)
-        return {"success": True, "feature_id": feature_id, "result": result, "timestamp": f["last_validated"]}
-
-    def _search_features(self, query: str) -> List[Dict]:
-        query = query.lower()
-        all_features = self._list_features({})
-        
-        matches = []
-        for f in all_features:
-            text = f"{f['name']} {f['description']} {' '.join(f.get('tags', []))}".lower()
-            if query in text:
-                matches.append(f)
-        
-        # Sort by relevance? For now just return matches
-        return matches[:20]