npcsh 1.0.14__py3-none-any.whl → 1.0.17__py3-none-any.whl

npcsh/mcp_server.py

@@ -14,7 +14,6 @@ from typing import Optional, Dict, Any, List, Union, Callable
 from mcp.server.fastmcp import FastMCP
 import importlib
 # npcpy imports
-from npcpy.gen.response import get_litellm_response
 
 
 import os
@@ -28,15 +27,27 @@ except:
 from typing import Optional, Dict, Any, List, Union, Callable, get_type_hints
 # Add these imports to the top of your file
 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)
+
 # Initialize the MCP server
-mcp = FastMCP("npcpy_enhanced")
+mcp = FastMCP("npcsh_mcp")
 
 # Define the default workspace
 DEFAULT_WORKSPACE = os.path.join(os.getcwd(), "workspace")
 os.makedirs(DEFAULT_WORKSPACE, exist_ok=True)
 
 # ==================== SYSTEM TOOLS ====================
-
 @mcp.tool()
 async def run_server_command(command: str) -> str:
     """
@@ -54,45 +65,44 @@ async def run_server_command(command: str) -> str:
             cwd=DEFAULT_WORKSPACE, 
             shell=True, 
             capture_output=True, 
-            text=True
+            text=True,
+            timeout=30  # Add timeout to prevent hanging
         )
-        return result.stdout or result.stderr
+        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 that fixes schema validation issues."""
+    """Create an async wrapper for sync functions."""
     
     @wraps(func)
-    async def async_wrapper(*args, **kwargs):
-        # Direct parameter dict case (most common failure)
-        if len(args) == 1 and isinstance(args[0], dict):
-            params = args[0]
-            
-            # Fix for search_web - add required kwargs parameter
-            if "kwargs" not in params:
-                # Create a new dict with the kwargs parameter added
-                params = {**params, "kwargs": ""}
-            
-            # Call the function with the parameters
-            if asyncio.iscoroutinefunction(func):
-                return await func(**params)
-            else:
-                return await asyncio.to_thread(func, **params)
+    async def async_wrapper(**kwargs):
+        func_name = func.__name__
+        print(f"MCP SERVER DEBUG: {func_name} called with kwargs={kwargs}", flush=True)
         
-        # Normal function call or other cases
-        if asyncio.iscoroutinefunction(func):
-            return await func(*args, **kwargs)
-        else:
-            return await asyncio.to_thread(func, *args, **kwargs)
+        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}"
     
-    # Preserve function metadata
     async_wrapper.__name__ = func.__name__
     async_wrapper.__doc__ = func.__doc__
     async_wrapper.__annotations__ = func.__annotations__
     
     return async_wrapper
 
-# Update your register_module_tools function to use this improved wrapper
+
+
 def register_module_tools(module_name: str) -> None:
     """
     Register all suitable functions from a module as MCP tools with improved argument handling.
@@ -133,45 +143,39 @@ def load_module_functions(module_name: str) -> List[Callable]:
 
 print("Loading tools from npcpy modules...")
 
-# Load modules from npcpy.routes
-try:
-    from npcpy.routes import routes
-    for route_name, route_func in routes.items():
-        if callable(route_func):
-            async_func = make_async_wrapper(route_func)
-            try:
-                mcp.tool()(async_func)
-                print(f"Registered route: {route_name}")
-            except Exception as e:
-                print(f"Failed to register route {route_name}: {e}")
-except ImportError as e:
-    print(f"Warning: Could not import routes: {e}")
 
 
-# Load npc_compiler functions
-print("Loading functions from npcpy.npc_compiler...")
-try:
-    import importlib.util
-    if importlib.util.find_spec("npcpy.npc_compiler"):
-        register_module_tools("npcpy.npc_compiler")
-except ImportError:
-    print("npcpy.npc_compiler not found, skipping...")
 
-# Load npc_sysenv functions
-#print("Loading functions from npcpy.npc_sysenv...")
-#register_module_tools("npcpy.npc_sysenv")
-register_module_tools("npcpy.memory.search")
 
-register_module_tools("npcpy.work.plan")
-register_module_tools("npcpy.work.trigger")
-register_module_tools("npcpy.work.desktop")
+def register_selected_npcpy_tools():
+    tools = [generate_group_candidates, 
+             abstract, 
+             extract_facts, 
+             zoom_in, 
+             execute_llm_command, 
+             gen_image, 
+             load_file_contents, 
+             capture_screenshot, 
+             search_web, ]
 
-#print("Loading functions from npcpy.command_history...")
-#register_module_tools("npcpy.memory.command_history")
+    for func in tools:
+        # Ensure a docstring exists for schema generation
+        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  # Some builtins may not allow setting __doc__
+
+        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()
 
 
-#print("Loading functions from npcpy.npc_sysenv...")
-#register_module_tools("npcpy.llm_funcs")
 
 
 # ==================== MAIN ENTRY POINT ====================

npcsh/npc.py

@@ -1,7 +1,6 @@
 import argparse
 import sys
 import os
-import sqlite3
 import traceback
 from typing import Optional
 
@@ -11,7 +10,8 @@ from npcsh._state import (
     NPCSH_API_URL, 
     NPCSH_DB_PATH, 
     NPCSH_STREAM_OUTPUT,
-    )
+    initial_state,
+)
 from npcpy.npc_sysenv import (
     print_and_process_stream_with_markdown,
     render_markdown,
@@ -19,8 +19,17 @@ from npcpy.npc_sysenv import (
 from npcpy.npc_compiler import NPC, Team
 from npcsh.routes import router
 from npcpy.llm_funcs import check_llm_command
+from sqlalchemy import create_engine
+
+# Import the key functions from npcsh
+from npcsh._state import (
+    setup_shell,
+    execute_slash_command,
+    execute_command,
+)
 
 def load_npc_by_name(npc_name: str = "sibiji", db_path: str = NPCSH_DB_PATH) -> Optional[NPC]:
+    """Load NPC by name, with fallback logic matching npcsh"""
     if not npc_name:
         npc_name = "sibiji"
 
@@ -37,7 +46,7 @@ def load_npc_by_name(npc_name: str = "sibiji", db_path: str = NPCSH_DB_PATH) ->
 
     if chosen_path:
         try:
-            db_conn = sqlite3.connect(db_path)
+            db_conn = create_engine(f'sqlite:///{NPCSH_DB_PATH}')
             npc = NPC(file=chosen_path, db_conn=db_conn)
             return npc
         except Exception as e:
@@ -50,6 +59,8 @@ def load_npc_by_name(npc_name: str = "sibiji", db_path: str = NPCSH_DB_PATH) ->
         return None
 
 def main():
+    from npcsh.routes import router
+    
     parser = argparse.ArgumentParser(
         description="NPC Command Line Utilities. Call a command or provide a prompt for the default NPC.",
         usage="npc <command> [command_args...] | <prompt> [--npc NAME] [--model MODEL] [--provider PROV]"
@@ -64,34 +75,38 @@ def main():
         "-n", "--npc", help="Name of the NPC to use (default: sibiji)", type=str, default="sibiji"
     )
 
-    # No subparsers setup at first - we'll conditionally create them
-
-    # First, get any arguments without parsing commands
+    # Parse arguments
     args, all_args = parser.parse_known_args()
     global_model = args.model
     global_provider = args.provider
 
-    # Check if the first argument is a known command
     is_valid_command = False
     command_name = None
-    if all_args and all_args[0] in router.get_commands():
-        is_valid_command = True
-        command_name = all_args[0]
-        all_args = all_args[1:]  # Remove the command from arguments
+    
+    if all_args:
+        first_arg = all_args[0]
+        if first_arg.startswith('/'):
+            is_valid_command = True
+            command_name = first_arg
+            all_args = all_args[1:]
+        elif first_arg in router.get_commands():
+            is_valid_command = True
+            command_name = '/' + first_arg
+            all_args = all_args[1:]
+
+
 
-    # Only set up subparsers if we have a valid command
     if is_valid_command:
         subparsers = parser.add_subparsers(dest="command", title="Available Commands",
                                          help="Run 'npc <command> --help' for command-specific help")
 
         for cmd_name, help_text in router.help_info.items():
-
             cmd_parser = subparsers.add_parser(cmd_name, help=help_text, add_help=False)
             cmd_parser.add_argument('command_args', nargs=argparse.REMAINDER,
                                     help='Arguments passed directly to the command handler')
 
         # Re-parse with command subparsers
-        args = parser.parse_args([command_name] + all_args)
+        args = parser.parse_args([command_name.lstrip('/')] + all_args)
         command_args = args.command_args if hasattr(args, 'command_args') else []
         unknown_args = []
     else:
@@ -104,67 +119,86 @@ def main():
         args.model = global_model
     if args.provider is None:
         args.provider = global_provider
-    # --- END OF FIX ---
-    npc_instance = load_npc_by_name(args.npc, NPCSH_DB_PATH)
-
-    effective_model = args.model or NPCSH_CHAT_MODEL
-    effective_provider = args.provider or NPCSH_CHAT_PROVIDER
-
 
+    # Use npcsh's setup_shell to get proper team and NPC setup
+    try:
+        command_history, team, forenpc_obj = setup_shell()
+    except Exception as e:
+        print(f"Warning: Could not set up full npcsh environment: {e}", file=sys.stderr)
+        print("Falling back to basic NPC loading...", file=sys.stderr)
+        team = None
+        forenpc_obj = load_npc_by_name(args.npc, NPCSH_DB_PATH)
+
+    # Determine which NPC to use
+    npc_instance = None
+    if team and args.npc in team.npcs:
+        npc_instance = team.npcs[args.npc]
+    elif team and args.npc == team.forenpc.name if team.forenpc else False:
+        npc_instance = team.forenpc
+    else:
+        npc_instance = load_npc_by_name(args.npc, NPCSH_DB_PATH)
 
-    extras = {}
+    if not npc_instance:
+        print(f"Error: Could not load NPC '{args.npc}'", file=sys.stderr)
+        sys.exit(1)
 
-    # Process command args if we have a valid command
-    if is_valid_command:
-        # Parse command args properly
-        if command_args:
-            i = 0
-            while i < len(command_args):
-                arg = command_args[i]
-                if arg.startswith("--"):
-                    param = arg[2:]  # Remove --
-                    if "=" in param:
-                        param_name, param_value = param.split("=", 1)
-                        extras[param_name] = param_value
-                        i += 1
-                    elif i + 1 < len(command_args) and not command_args[i+1].startswith("--"):
-                        extras[param] = command_args[i+1]
-                        i += 2
-                    else:
-                        extras[param] = True
-                        i += 1
-                else:
-                    i += 1
-            
-        handler = router.get_route(command_name)
-        if not handler:
-            print(f"Error: Command '{command_name}' recognized but no handler found.", file=sys.stderr)
-            sys.exit(1)
-
-        full_command_str = command_name
-        if command_args:
-            full_command_str += " " + " ".join(command_args)
+    # Now check for jinxs if we haven't identified a command yet
+    if not is_valid_command and all_args:
+        first_arg = all_args[0]
         
-        handler_kwargs = {
-            "model": effective_model,
-            "provider": effective_provider,
-            "npc": npc_instance,
-            "api_url": NPCSH_API_URL,
-            "stream": NPCSH_STREAM_OUTPUT,
-            "messages": [],
-            "team": None,
-            "current_path": os.getcwd(),
-            **extras
-        }
-
-        try:
-            result = handler(command=full_command_str, **handler_kwargs)
+        # Check if first argument is a jinx name
+        jinx_found = False
+        if team and first_arg in team.jinxs_dict:
+            jinx_found = True
+        elif isinstance(npc_instance, NPC) and hasattr(npc_instance, 'jinxs_dict') and first_arg in npc_instance.jinxs_dict:
+            jinx_found = True
+            
+        if jinx_found:
+            is_valid_command = True
+            command_name = '/' + first_arg
+            all_args = all_args[1:]
+
+    # Create a shell state object similar to npcsh
+    shell_state = initial_state
+    shell_state.npc = npc_instance
+    shell_state.team = team
+    shell_state.current_path = os.getcwd()
+    shell_state.stream_output = NPCSH_STREAM_OUTPUT
+
+    # Override model/provider if specified
+    effective_model = args.model or (npc_instance.model if npc_instance.model else NPCSH_CHAT_MODEL)
+    effective_provider = args.provider or (npc_instance.provider if npc_instance.provider else NPCSH_CHAT_PROVIDER)
+    
+    # Update the NPC's model/provider for this session if overridden
+    if args.model:
+        npc_instance.model = effective_model
+    if args.provider:
+        npc_instance.provider = effective_provider
+    try:
+        if is_valid_command:
+            # Handle slash command using npcsh's execute_slash_command
+            full_command_str = command_name
+            if command_args:
+                full_command_str += " " + " ".join(command_args)
+            
+            print(f"Executing command: {full_command_str}")
+            
+            updated_state, result = execute_slash_command(
+                full_command_str, 
+                stdin_input=None, 
+                state=shell_state, 
+                stream=NPCSH_STREAM_OUTPUT, 
+                router = router
+            )
 
+            # Process and display the result
             if isinstance(result, dict):
                 output = result.get("output") or result.get("response")
+                model_for_stream = result.get('model', effective_model)
+                provider_for_stream = result.get('provider', effective_provider)
                 
                 if NPCSH_STREAM_OUTPUT and not isinstance(output, str):
-                     print_and_process_stream_with_markdown(output, effective_model, effective_provider)
+                     print_and_process_stream_with_markdown(output, model_for_stream, provider_for_stream)
                 elif output is not None:
                      render_markdown(str(output))
             elif result is not None:
@@ -172,45 +206,38 @@ def main():
             else:
                 print(f"Command '{command_name}' executed.")
 
-        except Exception as e:
-            print(f"Error executing command '{command_name}': {e}", file=sys.stderr)
-            traceback.print_exc()
-            sys.exit(1)
-    else:
-        # Process as a prompt
-        prompt = " ".join(unknown_args)
+        else:
+            # Process as a regular prompt using npcsh's execution logic
+            prompt = " ".join(unknown_args)
 
-        if not prompt:
-            # If no prompt and no command, show help
-            parser.print_help()
-            sys.exit(1)
+            if not prompt:
+                # If no prompt and no command, show help
+                parser.print_help()
+                sys.exit(1)
 
-        print(f"Processing prompt: '{prompt}' with NPC: '{args.npc}'...")
-        try:
-            response_data = check_llm_command(
-                command=prompt,
-                model=effective_model,
-                provider=effective_provider,
-                npc=npc_instance,
-                stream=NPCSH_STREAM_OUTPUT,
-                messages=[],
-                team=None,
-                api_url=NPCSH_API_URL,
-            )
+            print(f"Processing prompt: '{prompt}' with NPC: '{args.npc}'...")
+            
+            # Use npcsh's execute_command but force it to chat mode for simple prompts
+            shell_state.current_mode = 'chat'
+            updated_state, result = execute_command(prompt, shell_state)
 
-            if isinstance(response_data, dict):
-                output = response_data.get("output")
+            # Process and display the result
+            if isinstance(result, dict):
+                output = result.get("output")
+                model_for_stream = result.get('model', effective_model)
+                provider_for_stream = result.get('provider', effective_provider)
+                
                 if NPCSH_STREAM_OUTPUT and hasattr(output, '__iter__') and not isinstance(output, (str, bytes, dict, list)):
-                    print_and_process_stream_with_markdown(output, effective_model, effective_provider)
+                    print_and_process_stream_with_markdown(output, model_for_stream, provider_for_stream)
                 elif output is not None:
                     render_markdown(str(output))
-            elif response_data is not None:
-                 render_markdown(str(response_data))
+            elif result is not None:
+                 render_markdown(str(result))
 
-        except Exception as e:
-            print(f"Error processing prompt: {e}", file=sys.stderr)
-            traceback.print_exc()
-            sys.exit(1)
+    except Exception as e:
+        print(f"Error executing command: {e}", file=sys.stderr)
+        traceback.print_exc()
+        sys.exit(1)
 
 if __name__ == "__main__":
     main()