nucleus-mcp 1.0.7 → 1.2.0

package/src/mcp_server_nucleus/runtime/schema_gen.py

@@ -1,140 +0,0 @@
-
-import json
-from typing import Dict, Any
-import logging
-
-logger = logging.getLogger("nucleus.schema")
-
-def _to_json_serializable(obj):
-    """Helper to convert Pydantic models/objects to serializable dicts."""
-    if hasattr(obj, "model_dump"):
-        return obj.model_dump()
-    if hasattr(obj, "dict"):
-        return obj.dict()
-    if isinstance(obj, list):
-        return [_to_json_serializable(item) for item in obj]
-    if isinstance(obj, dict):
-        return {k: _to_json_serializable(v) for k, v in obj.items()}
-    # Handle specific MCP objects if needed
-    return str(obj)
-
-async def generate_tool_schema(mcp) -> Dict[str, Any]:
-    """
-    Introspects the MCP server and generates a combined JSON Schema for tools, prompts, and resources.
-    """
-    try:
-        schema = {
-            "openapi": "3.0.0",
-            "info": {
-                "title": f"{mcp.name} API",
-                "version": getattr(mcp, "version", "0.5.0"),
-                "description": "Auto-generated schema for Nucleus MCP Tools, Prompts, and Resources"
-            },
-            "paths": {},
-            "components": {
-                "schemas": {}
-            }
-        }
-        
-        # 1. Tools
-        tool_names = await mcp.get_tools()
-        for name in tool_names:
-            tool = await mcp.get_tool(name)
-            path = f"/tools/{tool.name}"
-            schema["paths"][path] = {
-                "post": {
-                    "summary": f"Tool: {tool.name}",
-                    "description": tool.description,
-                    "operationId": f"tool_{tool.name}",
-                    "requestBody": {
-                        "content": {
-                            "application/json": {
-                                "schema": _to_json_serializable(tool.parameters)
-                            }
-                        }
-                    },
-                    "responses": {
-                        "200": {
-                            "description": "Successful tool execution",
-                            "content": {
-                                "application/json": {
-                                    "schema": _to_json_serializable(tool.output_schema) if tool.output_schema else {"type": "object"}
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        
-        # 2. Prompts
-        try:
-            prompt_names = await mcp.get_prompts()
-            for name in prompt_names:
-                prompt = await mcp.get_prompt(name)
-                path = f"/prompts/{prompt.name}"
-                schema["paths"][path] = {
-                    "post": {
-                        "summary": f"Prompt: {prompt.name}",
-                        "description": prompt.description,
-                        "operationId": f"prompt_{prompt.name}",
-                        "requestBody": {
-                            "content": {
-                                "application/json": {
-                                    "schema": {
-                                        "type": "object",
-                                        "properties": {
-                                            arg.name: {
-                                                "description": arg.description,
-                                                "type": "string" # MCP prompt args are usually strings
-                                            } for arg in getattr(prompt, "arguments", [])
-                                        },
-                                        "required": [arg.name for arg in getattr(prompt, "arguments", []) if getattr(arg, "required", False)]
-                                    }
-                                }
-                            }
-                        },
-                        "responses": {
-                            "200": {
-                                "description": "Successful prompt render"
-                            }
-                        }
-                    }
-                }
-        except Exception as e:
-            logger.warning(f"Failed to introspect prompts: {e}")
-
-        # 3. Resources
-        try:
-            resources = await mcp.get_resources()
-            for uri in resources:
-                resource = await mcp.get_resource(uri)
-                path = f"/resources/{resource.name}"
-                schema["paths"][path] = {
-                    "get": {
-                        "summary": f"Resource: {resource.name}",
-                        "description": f"{resource.description} (URI: {resource.uri})",
-                        "operationId": f"resource_{resource.name}",
-                        "responses": {
-                            "200": {
-                                "description": "Successful resource read",
-                                "content": {
-                                    resource.mime_type or "text/plain": {}
-                                }
-                            }
-                        }
-                    }
-                }
-        except Exception as e:
-            logger.warning(f"Failed to introspect resources: {e}")
-            
-        return schema
-    except Exception as e:
-        logger.error(f"Error generating schema: {e}")
-        return {"error": str(e)}
-
-def export_schema_to_file(schema: Dict[str, Any], output_path: str):
-    """
-    Writes the generated schema to a JSON file.
-    """
-    with open(output_path, "w") as f:
-        json.dump(schema, f, indent=2)

package/src/mcp_server_nucleus/runtime/session_ops.py

@@ -1,224 +0,0 @@
-"""
-Nucleus Runtime - Session Operations
-====================================
-Core logic for session management (Save, Resume, Context switching).
-"""
-
-import json
-import time
-from typing import Dict, Any, List, Optional
-from pathlib import Path
-
-from .common import get_brain_path
-from .event_ops import _emit_event
-
-def _get_sessions_path() -> Path:
-    """Get path to sessions directory."""
-    brain = get_brain_path()
-    return brain / "sessions"
-
-def _get_active_session_path() -> Path:
-    """Get path to active session file."""
-    brain = get_brain_path()
-    return brain / "sessions" / "active.json"
-
-def _get_depth_state_safe() -> Dict:
-    """Get current depth tracking state (helper for session save)."""
-    try:
-        brain = get_brain_path()
-        depth_path = brain / "session" / "depth.json"
-        if depth_path.exists():
-            with open(depth_path, "r") as f:
-                return json.load(f)
-    except Exception:
-        pass
-    return {"current_depth": 0, "levels": []}
-
-def _save_session(context: str, active_task: Optional[str] = None,
-                  pending_decisions: Optional[List[str]] = None,
-                  breadcrumbs: Optional[List[str]] = None,
-                  next_steps: Optional[List[str]] = None) -> Dict[str, Any]:
-    """Save current session for later resumption."""
-    try:
-        sessions_dir = _get_sessions_path()
-        sessions_dir.mkdir(parents=True, exist_ok=True)
-        
-        timestamp = time.strftime("%Y%m%d_%H%M%S")
-        context_slug = context.lower().replace(" ", "_")[:30]
-        session_id = f"{context_slug}_{timestamp}"
-        
-        depth_state = _get_depth_state_safe()
-        
-        session = {
-            "schema_version": "1.0",
-            "nucleus_version": "0.5.0",
-            "id": session_id,
-            "context": context,
-            "active_task": active_task or "Not specified",
-            "pending_decisions": pending_decisions or [],
-            "breadcrumbs": breadcrumbs or [],
-            "next_steps": next_steps or [],
-            "depth_snapshot": {
-                "current_depth": depth_state.get("current_depth", 0),
-                "levels": depth_state.get("levels", [])
-            },
-            "created_at": time.strftime("%Y-%m-%dT%H:%M:%S%z"),
-            "is_active": True
-        }
-        
-        session_path = sessions_dir / f"{session_id}.json"
-        with open(session_path, "w") as f:
-            json.dump(session, f, indent=2)
-            
-        with open(_get_active_session_path(), "w") as f:
-            json.dump({"active_session_id": session_id}, f)
-            
-        _prune_old_sessions(max_sessions=10)
-        
-        _emit_event(
-            "session_saved",
-            "brain_save_session",
-            {
-                "session_id": session_id,
-                "context": context,
-                "active_task": active_task or "Not specified"
-            },
-            description=f"Session saved: {context}"
-        )
-        
-        return {
-            "success": True,
-            "session_id": session_id,
-            "context": context,
-            "message": "Session saved. Resume later with: nucleus sessions resume"
-        }
-    except Exception as e:
-        return {"error": str(e)}
-
-def _prune_old_sessions(max_sessions: int = 10) -> None:
-    """Keep only the most recent N sessions."""
-    try:
-        sessions_dir = _get_sessions_path()
-        if not sessions_dir.exists():
-            return
-            
-        session_files = sorted(
-            sessions_dir.glob("*.json"),
-            key=lambda f: f.stat().st_mtime,
-            reverse=True
-        )
-        session_files = [f for f in session_files if f.name != "active.json"]
-        
-        for old_session in session_files[max_sessions:]:
-            try:
-                old_session.unlink()
-            except Exception:
-                pass
-    except Exception:
-        pass
-
-def _get_session(session_id: str) -> Dict[str, Any]:
-    """Get a specific session by ID."""
-    try:
-        sessions_dir = _get_sessions_path()
-        session_path = sessions_dir / f"{session_id}.json"
-        
-        if not session_path.exists():
-            return {"error": f"Session '{session_id}' not found"}
-        
-        with open(session_path) as f:
-            session = json.load(f)
-        
-        return {"session": session}
-    except Exception as e:
-        return {"error": str(e)}
-
-def _resume_session(session_id: Optional[str] = None) -> Dict[str, Any]:
-    """Resume a saved session."""
-    try:
-        if not session_id:
-            active_path = _get_active_session_path()
-            if active_path.exists():
-                with open(active_path) as f:
-                    active_data = json.load(f)
-                    session_id = active_data.get("active_session_id")
-        
-        if not session_id:
-            return {"error": "No active session found"}
-            
-        session_result = _get_session(session_id)
-        if "error" in session_result:
-            return session_result
-            
-        session = session_result.get("session", {})
-        
-        # Version Checks
-        warnings = []
-        if session.get("schema_version") != "1.0":
-             warnings.append(f"Schema mismatch: Session uses v{session.get('schema_version', 'unknown')}, System uses v1.0")
-        if session.get("nucleus_version") != "0.5.0":
-             warnings.append(f"Nucleus update: Session from v{session.get('nucleus_version', 'unknown')}, System is v0.5.0")
-
-        created_str = session.get("created_at", "")
-        # Simple recent check 
-        is_recent = True 
-        try:
-             if created_str:
-                 # Very basic check
-                 pass
-        except Exception:
-             pass
-
-        return {
-            "session_id": session_id,
-            "context": session.get("context"),
-            "active_task": session.get("active_task"),
-            "pending_decisions": session.get("pending_decisions", []),
-            "breadcrumbs": session.get("breadcrumbs", []),
-            "next_steps": session.get("next_steps", []),
-            "depth_snapshot": session.get("depth_snapshot", {}),
-            "created_at": created_str,
-            "warnings": warnings,
-            "is_recent": is_recent
-        }
-    except Exception as e:
-        return {"error": str(e)}
-
-def _list_sessions() -> Dict[str, Any]:
-    """List all saved sessions."""
-    try:
-        sessions_dir = _get_sessions_path()
-        if not sessions_dir.exists():
-            return {"sessions": [], "total": 0}
-            
-        sessions = []
-        for session_file in sorted(sessions_dir.glob("*.json"), reverse=True):
-            if session_file.name == "active.json":
-                continue
-            try:
-                with open(session_file) as f:
-                    session = json.load(f)
-                sessions.append({
-                    "id": session.get("id"),
-                    "context": session.get("context"),
-                    "created_at": session.get("created_at")
-                })
-            except Exception:
-                continue
-                
-        return {"sessions": sessions, "total": len(sessions)}
-    except Exception as e:
-        return {"error": str(e)}
-
-def _check_for_recent_session() -> Dict[str, Any]:
-    """Check for recent session."""
-    try:
-        active_path = _get_active_session_path()
-        if active_path.exists():
-            with open(active_path) as f:
-                sid = json.load(f).get("active_session_id")
-            if sid:
-                return {"exists": True, "session_id": sid, "message": "Resumable session found."}
-        return {"exists": False}
-    except Exception:
-        return {"exists": False}