npcsh 0.1.2__py3-none-any.whl → 1.1.13__py3-none-any.whl

npcsh/mcp_helpers.py

@@ -0,0 +1,357 @@
+#!/usr/bin/env python
+"""
+Raw MCP client with no exception handling and full visibility.
+"""
+
+import asyncio
+import os
+import sys
+import json
+try:
+    import inspect
+except: 
+    pass
+from typing import Optional, List, Dict, Any
+from contextlib import AsyncExitStack
+
+
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+
+from npcpy.gen.response import get_litellm_response
+from npcsh._state import (
+    NPCSH_CHAT_MODEL,
+    NPCSH_CHAT_PROVIDER,
+    NPCSH_API_URL,
+)
+
+class MCPClient:
+    """
+    Raw MCP Client with no exception handling.
+    """
+    
+    def __init__(
+        self,
+        model: str = NPCSH_CHAT_MODEL,
+        provider: str = NPCSH_CHAT_PROVIDER,
+        api_url: str = NPCSH_API_URL,
+        api_key: Optional[str] = None,
+        debug: bool = True,
+    ):
+        self.model = model
+        self.provider = provider
+        self.api_url = api_url
+        self.api_key = api_key
+        self.debug = debug
+        self.session = None
+        self.exit_stack = AsyncExitStack()
+        self.tools = []
+        self.available_tools = []
+        
+    def _log(self, message: str) -> None:
+        """Log debug messages."""
+        if self.debug:
+            print(f"[MCP Client] {message}")
+
+    async def connect_to_server(self, server_script_path: str) -> None:
+        """
+        Connect to an MCP server.
+        
+        Args:
+            server_script_path: Path to the server script (.py or .js)
+        """
+        self._log(f"Connecting to server: {server_script_path}")
+        
+      
+        command = "python" if server_script_path.endswith('.py') else "node"
+        server_params = StdioServerParameters(
+            command=command,
+            args=[server_script_path],
+            env=None
+        )
+        
+      
+        stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_params))
+        read, write = stdio_transport
+        
+      
+        self.session = await self.exit_stack.enter_async_context(ClientSession(read, write))
+        
+      
+        await self.session.initialize()
+        
+      
+        response = await self.session.list_tools()
+        self.tools = response.tools
+        
+      
+        for tool in self.tools:
+            print(f"\nJinx: {tool.name}")
+            print(f"Description: {tool.description}")
+            
+          
+            for attribute_name in dir(tool):
+                if not attribute_name.startswith('_'):
+                    attribute = getattr(tool, attribute_name)
+                    if not callable(attribute):
+                        print(f"  {attribute_name}: {attribute}")
+            
+          
+            if hasattr(tool, 'source'):
+                print(f"Source: {tool.source}")
+                
+          
+            try:
+                tool_module = inspect.getmodule(tool)
+                if tool_module:
+                    print(f"Module: {tool_module.__name__}")
+                    if hasattr(tool_module, tool.name):
+                        tool_func = getattr(tool_module, tool.name)
+                        if callable(tool_func):
+                            print(f"Function signature: {inspect.signature(tool_func)}")
+            except:
+                pass
+        
+      
+        self.available_tools = []
+        for tool in self.tools:
+          
+            schema = getattr(tool, "inputSchema", {})
+            
+          
+            tool_info = {
+                "type": "function",
+                "function": {
+                    "name": tool.name,
+                    "description": tool.description,
+                    "parameters": schema
+                }
+            }
+            self.available_tools.append(tool_info)
+            
+          
+            print(f"\nJinx schema for {tool.name}:")
+            print(json.dumps(schema, indent=2))
+        
+        tool_names = [tool.name for tool in self.tools]
+        self._log(f"Available tools: {', '.join(tool_names)}")
+
+    async def process_query(
+        self,
+        query: str,
+        messages: Optional[List[Dict[str, str]]] = None,
+        stream: bool = False
+    ) -> Dict[str, Any]:
+        """
+        Process a query using the LLM and available tools.
+        
+        Args:
+            query: User query
+            messages: Optional conversation history
+            stream: Whether to stream the response
+            
+        Returns:
+            Dict with response text and updated messages
+        """
+        self._log(f"Processing query: {query}")
+        
+      
+        if messages is None:
+            messages = []
+            
+        current_messages = messages.copy()
+        if not current_messages or current_messages[-1]["role"] != "user":
+            current_messages.append({"role": "user", "content": query})
+        elif current_messages[-1]["role"] == "user":
+            current_messages[-1]["content"] = query
+            
+      
+        self._log("Making initial LLM call with tools")
+        response = get_litellm_response(
+            model=self.model,
+            provider=self.provider,
+            api_url=self.api_url,
+            api_key=self.api_key,
+            messages=current_messages,
+            tools=self.available_tools,
+            stream=False
+        )
+        
+      
+        print("\nLLM Response:")
+        print(json.dumps(response, indent=2, default=str))
+        
+      
+        response_content = response.get("response", "")
+        tool_calls = response.get("tool_calls", [])
+        
+      
+        print("\nJinx Calls:")
+        print(json.dumps(tool_calls, indent=2, default=str))
+        
+      
+        final_text = []
+        
+      
+        if response_content and not tool_calls:
+            final_text.append(response_content)
+            
+          
+            current_messages.append({
+                "role": "assistant",
+                "content": response_content
+            })
+        
+      
+        if tool_calls:
+            self._log(f"Processing {len(tool_calls)} tool calls")
+            
+          
+            assistant_message = {
+                "role": "assistant",
+                "content": response_content if response_content else None,
+                "tool_calls": []
+            }
+            
+          
+            for tool_call in tool_calls:
+              
+                if isinstance(tool_call, dict):
+                    tool_id = tool_call.get("id", "")
+                    tool_name = tool_call.get("function", {}).get("name", "")
+                    tool_args = tool_call.get("function", {}).get("arguments", {})
+                else:
+                  
+                    tool_id = getattr(tool_call, "id", "")
+                    tool_name = getattr(tool_call.function, "name", "")
+                    tool_args = getattr(tool_call.function, "arguments", {})
+                
+              
+                if isinstance(tool_args, str):
+                    print(f"\nJinx args is string: {tool_args}")
+                    tool_args = json.loads(tool_args)
+                    print(f"Parsed to: {tool_args}")
+                
+              
+                assistant_message["tool_calls"].append({
+                    "id": tool_id,
+                    "type": "function",
+                    "function": {
+                        "name": tool_name,
+                        "arguments": json.dumps(tool_args) if isinstance(tool_args, dict) else tool_args
+                    }
+                })
+                
+              
+                self._log(f"Executing tool: {tool_name} with args: {tool_args}")
+                print(f"\nExecuting tool call:")
+                print(f"  Jinx name: {tool_name}")
+                print(f"  Jinx args: {tool_args}")
+                print(f"  Jinx args type: {type(tool_args)}")
+                
+                final_text.append(f"[Calling tool {tool_name} with args {tool_args}]")
+                
+              
+                result = await self.session.call_tool(tool_name, tool_args)
+                
+              
+                print("\nJinx Result:")
+                print(f"  Result: {result}")
+                print(f"  Content: {result.content}")
+                print(f"  Content type: {type(result.content)}")
+                
+                tool_result = result.content
+                
+              
+                if hasattr(tool_result, 'text'):
+                    print(f"  TextContent detected, text: {tool_result.text}")
+                    tool_result = tool_result.text
+                elif isinstance(tool_result, list) and all(hasattr(item, 'text') for item in tool_result):
+                    print(f"  List of TextContent detected")
+                    tool_result = [item.text for item in tool_result]
+                
+              
+                current_messages.append(assistant_message)
+                current_messages.append({
+                    "role": "tool",
+                    "tool_call_id": tool_id,
+                    "content": json.dumps(tool_result) if not isinstance(tool_result, str) else str(tool_result)
+                })
+            
+          
+            print("\nUpdated Messages:")
+            print(json.dumps(current_messages, indent=2, default=str))
+            
+          
+            self._log("Getting final response after tool calls")
+            final_response = get_litellm_response(
+                model=self.model,
+                provider=self.provider,
+                api_url=self.api_url,
+                api_key=self.api_key,
+                messages=current_messages,
+                stream=stream
+            )
+            
+            final_text.append(final_response.get("response", ""))
+            
+          
+            current_messages.append({
+                "role": "assistant",
+                "content": final_response.get("response", "")
+            })
+        
+        return {
+            "response": "\n".join(final_text),
+            "messages": current_messages
+        }
+
+    async def chat_loop(self):
+        """Run an interactive chat loop"""
+        print("\nMCP Client Started!")
+        print("Type your queries or 'quit' to exit.")
+        
+        messages = []
+        
+        while True:
+            query = input("\nQuery: ").strip()
+            
+            if query.lower() == 'quit':
+                break
+            
+          
+            result = await self.process_query(query, messages)
+            messages = result.get("messages", [])
+            
+          
+            print("\nResponse:")
+            print(result.get("response", ""))
+
+    async def cleanup(self):
+        """Clean up resources"""
+        self._log("Cleaning up resources")
+        await self.exit_stack.aclose()
+
+async def main():
+    """Entry point for the MCP client."""
+    if len(sys.argv) < 2:
+        print("Usage: python raw_mcp_client.py <path_to_server_script>")
+        sys.exit(1)
+        
+    server_script = sys.argv[1]
+    
+  
+    client = MCPClient()
+    
+  
+    await client.connect_to_server(server_script)
+    
+  
+    await client.chat_loop()
+    
+  
+    await client.cleanup()
+
+if __name__ == "__main__":
+    asyncio.run(main())

npcsh/mcp_server.py

@@ -0,0 +1,299 @@
+
+"""
+Enhanced MCP server that incorporates functionality from npcpy.routes, 
+npcpy.llm_funcs, and npcpy.npc_compiler as tools.
+"""
+
+import os
+import subprocess
+import json
+import asyncio
+
+from typing import Optional, Dict, Any, List, Union, Callable
+
+from mcp.server.fastmcp import FastMCP
+import importlib
+
+from sqlalchemy import text
+
+
+import os
+import subprocess
+import json
+import asyncio
+try:
+    import inspect
+except: 
+    pass
+from typing import Optional, Dict, Any, List, Union, Callable, get_type_hints
+
+from functools import wraps
+import sys 
+
+from npcpy.llm_funcs import  generate_group_candidates, abstract, extract_facts, zoom_in,   execute_llm_command, gen_image
+from npcpy.memory.search import search_similar_texts, execute_search_command, execute_rag_command,  answer_with_rag, execute_brainblast_command
+from npcpy.data.load import load_file_contents
+from npcpy.memory.command_history import CommandHistory
+from npcpy.data.image import capture_screenshot
+from npcpy.data.web import search_web
+
+from npcsh._state import NPCSH_DB_PATH
+
+command_history = CommandHistory(db=NPCSH_DB_PATH)
+
+mcp = FastMCP("npcsh_mcp")
+
+
+DEFAULT_WORKSPACE = os.path.join(os.getcwd(), "workspace")
+os.makedirs(DEFAULT_WORKSPACE, exist_ok=True)
+
+@mcp.tool()
+async def add_memory(
+    npc_name: str,
+    team_name: str,
+    content: str,
+    memory_type: str = "observation",
+    directory_path: str = None
+) -> str:
+    """
+    Add a memory entry to the database.
+    
+    Args:
+        npc_name: Name of the NPC this memory belongs to
+        team_name: Name of the team the NPC belongs to
+        content: The memory content to store
+        memory_type: Type of memory (observation, preference, achievement, etc.)
+        directory_path: Directory path context (defaults to current working directory)
+        
+    Returns:
+        Success message with memory ID or error message
+    """
+    if directory_path is None:
+        directory_path = os.getcwd()
+    
+    try:
+        from npcpy.memory.command_history import generate_message_id
+        message_id = generate_message_id()
+        
+        memory_id = command_history.add_memory_to_database(
+            message_id=message_id,
+            conversation_id='mcp_direct',
+            npc=npc_name,
+            team=team_name,
+            directory_path=directory_path,
+            initial_memory=content,
+            status='active',
+            model=None,
+            provider=None
+        )
+        return f"Memory created successfully with ID: {memory_id}"
+    except Exception as e:
+        return f"Error creating memory: {str(e)}"
+
+@mcp.tool()
+async def search_memory(
+    query: str,
+    npc_name: str = None,
+    team_name: str = None,
+    directory_path: str = None,
+    status_filter: str = None,
+    limit: int = 10
+) -> str:
+    """
+    Search memories in the database.
+    
+    Args:
+        query: Search query text
+        npc_name: Filter by specific NPC (optional)
+        team_name: Filter by specific team (optional)
+        directory_path: Filter by directory path (optional)
+        status_filter: Filter by memory status (active, archived, etc.)
+        limit: Maximum number of results to return
+        
+    Returns:
+        JSON string of matching memories or error message
+    """
+    if directory_path is None:
+        directory_path = os.getcwd()
+    
+    try:
+        results = command_history.search_memory(
+            query=query,
+            npc=npc_name,
+            team=team_name,
+            directory_path=directory_path,
+            status_filter=status_filter,
+            limit=limit
+        )
+        return json.dumps(results, indent=2)
+    except Exception as e:
+        return f"Error searching memories: {str(e)}"
+
+@mcp.tool()
+async def query_npcsh_database(sql_query: str) -> str:
+    """
+    Execute a SQL query against the npcsh_history.db database.
+    
+    Args:
+        sql_query: SQL query to execute (SELECT statements only for safety)
+        
+    Returns:
+        JSON string of query results or error message
+    """
+    # Safety check - only allow SELECT queries
+    if not sql_query.strip().upper().startswith('SELECT'):
+        return "Error: Only SELECT queries are allowed for safety"
+    
+    try:
+        with command_history.engine.connect() as conn:
+            result = conn.execute(text(sql_query))
+            rows = result.fetchall()
+            
+            if not rows:
+                return "Query executed successfully but returned no results"
+            
+            # Convert to list of dictionaries
+            columns = result.keys()
+            results = []
+            for row in rows:
+                row_dict = dict(zip(columns, row))
+                results.append(row_dict)
+            
+            return json.dumps(results, indent=2, default=str)
+    except Exception as e:
+        return f"Database query error: {str(e)}"
+@mcp.tool()
+async def run_server_command(command: str, wd: str) -> str:
+    """
+    Run a terminal command in the workspace.
+    
+    Args:
+        command: The shell command to run
+        wd: The working directory to run the command in
+        
+    Returns:
+        The command output or an error message.
+    """
+    try:
+        result = subprocess.run(
+            command, 
+            cwd=wd,
+            shell=True, 
+            capture_output=True, 
+            text=True,
+            timeout=30
+        )
+        return result.stdout or result.stderr or "Command completed with no output"
+    except subprocess.TimeoutExpired:
+        return "Command timed out after 30 seconds"
+    except Exception as e:
+        return str(e)
+
+
+
+def make_async_wrapper(func: Callable) -> Callable:
+    """Create an async wrapper for sync functions."""
+    
+    @wraps(func)
+    async def async_wrapper(**kwargs):
+        func_name = func.__name__
+        print(f"MCP SERVER DEBUG: {func_name} called with kwargs={kwargs}", flush=True)
+        
+        try:
+            result = func(**kwargs)
+            print(f"MCP SERVER DEBUG: {func_name} returned type={type(result)}, result={result[:500] if isinstance(result, str) else result}", flush=True)
+            return result
+                
+        except Exception as e:
+            print(f"MCP SERVER DEBUG: {func_name} exception: {e}", flush=True)
+            import traceback
+            traceback.print_exc()
+            return f"Error in {func_name}: {e}"
+    
+    async_wrapper.__name__ = func.__name__
+    async_wrapper.__doc__ = func.__doc__
+    async_wrapper.__annotations__ = func.__annotations__
+    
+    return async_wrapper
+
+
+
+def register_module_tools(module_name: str) -> None:
+    """
+    Register all suitable functions from a module as MCP tools with improved argument handling.
+    """
+    functions = load_module_functions(module_name)
+    for func in functions:
+      
+        if not func.__doc__:
+            print(f"Skipping function without docstring: {func.__name__}")
+            continue
+            
+      
+        async_func = make_async_wrapper(func)
+        
+      
+        try:
+            mcp.tool()(async_func)
+            print(f"Registered tool: {func.__name__}")
+        except Exception as e:
+            print(f"Failed to register {func.__name__}: {e}")
+def load_module_functions(module_name: str) -> List[Callable]:
+    """
+    Dynamically load functions from a module.
+    """
+    try:
+        module = importlib.import_module(module_name)
+      
+        functions = []
+        for name, func in inspect.getmembers(module, callable):
+            if not name.startswith('_'):
+              
+                if inspect.isfunction(func) or inspect.ismethod(func):
+                    functions.append(func)
+        return functions
+    except ImportError as e:
+        print(f"Warning: Could not import module {module_name}: {e}")
+        return []
+
+print("Loading tools from npcpy modules...")
+
+
+
+
+
+def register_selected_npcpy_tools():
+    tools = [              
+             gen_image, 
+             load_file_contents, 
+             capture_screenshot, 
+             search_web, ]
+
+    for func in tools:
+      
+        if not (getattr(func, "__doc__", None) and func.__doc__.strip()):
+            fallback_doc = f"Tool wrapper for {func.__name__}."
+            try:
+                func.__doc__ = fallback_doc
+            except Exception:
+                pass
+
+        try:
+            async_func = make_async_wrapper(func)
+            mcp.tool()(async_func)
+            print(f"Registered npcpy tool: {func.__name__}")
+        except Exception as e:
+            print(f"Failed to register npcpy tool {func.__name__}: {e}")
+register_selected_npcpy_tools()
+
+
+
+
+
+
+if __name__ == "__main__":
+    print(f"Starting enhanced NPCPY MCP server...")
+    print(f"Workspace: {DEFAULT_WORKSPACE}")
+    
+  
+    mcp.run(transport="stdio")