npcsh 1.0.25__py3-none-any.whl → 1.0.27__py3-none-any.whl

npcsh/mcp_helpers.py

@@ -14,11 +14,11 @@ except:
 from typing import Optional, List, Dict, Any
 from contextlib import AsyncExitStack
 
-# MCP imports
+
 from mcp import ClientSession, StdioServerParameters
 from mcp.client.stdio import stdio_client
 
-# Local imports from npcpy
+
 from npcpy.gen.response import get_litellm_response
 from npcsh._state import (
     NPCSH_CHAT_MODEL,
@@ -63,7 +63,7 @@ class MCPClient:
         """
         self._log(f"Connecting to server: {server_script_path}")
         
-        # Configure server parameters
+      
         command = "python" if server_script_path.endswith('.py') else "node"
         server_params = StdioServerParameters(
             command=command,
@@ -71,37 +71,37 @@ class MCPClient:
             env=None
         )
         
-        # Set up the connection
+      
         stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_params))
         read, write = stdio_transport
         
-        # Create the session
+      
         self.session = await self.exit_stack.enter_async_context(ClientSession(read, write))
         
-        # Initialize the session
+      
         await self.session.initialize()
         
-        # List available tools
+      
         response = await self.session.list_tools()
         self.tools = response.tools
         
-        # Display tool details for debugging
+      
         for tool in self.tools:
             print(f"\nJinx: {tool.name}")
             print(f"Description: {tool.description}")
             
-            # Print all attributes
+          
             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}")
             
-            # Check if the tool has source or function definition
+          
             if hasattr(tool, 'source'):
                 print(f"Source: {tool.source}")
                 
-            # Try to inspect the tool function
+          
             try:
                 tool_module = inspect.getmodule(tool)
                 if tool_module:
@@ -113,13 +113,13 @@ class MCPClient:
             except:
                 pass
         
-        # Convert tools to the format expected by the LLM
+      
         self.available_tools = []
         for tool in self.tools:
-            # Use inputSchema if available, otherwise create a default schema
+          
             schema = getattr(tool, "inputSchema", {})
             
-            # Create tool definition for LLM
+          
             tool_info = {
                 "type": "function",
                 "function": {
@@ -130,7 +130,7 @@ class MCPClient:
             }
             self.available_tools.append(tool_info)
             
-            # Print the schema for debugging
+          
             print(f"\nJinx schema for {tool.name}:")
             print(json.dumps(schema, indent=2))
         
@@ -156,7 +156,7 @@ class MCPClient:
         """
         self._log(f"Processing query: {query}")
         
-        # Initialize or update messages
+      
         if messages is None:
             messages = []
             
@@ -166,7 +166,7 @@ class MCPClient:
         elif current_messages[-1]["role"] == "user":
             current_messages[-1]["content"] = query
             
-        # Initial LLM call with tools
+      
         self._log("Making initial LLM call with tools")
         response = get_litellm_response(
             model=self.model,
@@ -175,65 +175,65 @@ class MCPClient:
             api_key=self.api_key,
             messages=current_messages,
             tools=self.available_tools,
-            stream=False  # Don't stream the initial call
+            stream=False
         )
         
-        # Print full response for debugging
+      
         print("\nLLM Response:")
         print(json.dumps(response, indent=2, default=str))
         
-        # Extract response content and tool calls
+      
         response_content = response.get("response", "")
         tool_calls = response.get("tool_calls", [])
         
-        # Print tool calls for debugging
+      
         print("\nJinx Calls:")
         print(json.dumps(tool_calls, indent=2, default=str))
         
-        # Create final text buffer
+      
         final_text = []
         
-        # If we have plain text response with no tool calls
+      
         if response_content and not tool_calls:
             final_text.append(response_content)
             
-            # Update messages with assistant response
+          
             current_messages.append({
                 "role": "assistant",
                 "content": response_content
             })
         
-        # Process tool calls if any
+      
         if tool_calls:
             self._log(f"Processing {len(tool_calls)} tool calls")
             
-            # Get the assistant message with tool calls
+          
             assistant_message = {
                 "role": "assistant",
                 "content": response_content if response_content else None,
                 "tool_calls": []
             }
             
-            # Process each tool call
+          
             for tool_call in tool_calls:
-                # Extract tool info based on format
+              
                 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:
-                    # Assume object with attributes
+                  
                     tool_id = getattr(tool_call, "id", "")
                     tool_name = getattr(tool_call.function, "name", "")
                     tool_args = getattr(tool_call.function, "arguments", {})
                 
-                # Parse arguments if it's a string
+              
                 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}")
                 
-                # Add tool call to assistant message
+              
                 assistant_message["tool_calls"].append({
                     "id": tool_id,
                     "type": "function",
@@ -243,7 +243,7 @@ class MCPClient:
                     }
                 })
                 
-                # Execute tool call
+              
                 self._log(f"Executing tool: {tool_name} with args: {tool_args}")
                 print(f"\nExecuting tool call:")
                 print(f"  Jinx name: {tool_name}")
@@ -252,10 +252,10 @@ class MCPClient:
                 
                 final_text.append(f"[Calling tool {tool_name} with args {tool_args}]")
                 
-                # Call the tool with the arguments exactly as received
+              
                 result = await self.session.call_tool(tool_name, tool_args)
                 
-                # Print full result for debugging
+              
                 print("\nJinx Result:")
                 print(f"  Result: {result}")
                 print(f"  Content: {result.content}")
@@ -263,7 +263,7 @@ class MCPClient:
                 
                 tool_result = result.content
                 
-                # Handle TextContent objects
+              
                 if hasattr(tool_result, 'text'):
                     print(f"  TextContent detected, text: {tool_result.text}")
                     tool_result = tool_result.text
@@ -271,7 +271,7 @@ class MCPClient:
                     print(f"  List of TextContent detected")
                     tool_result = [item.text for item in tool_result]
                 
-                # Add tool result to messages
+              
                 current_messages.append(assistant_message)
                 current_messages.append({
                     "role": "tool",
@@ -279,11 +279,11 @@ class MCPClient:
                     "content": json.dumps(tool_result) if not isinstance(tool_result, str) else str(tool_result)
                 })
             
-            # Print updated messages for debugging
+          
             print("\nUpdated Messages:")
             print(json.dumps(current_messages, indent=2, default=str))
             
-            # Get final response with tool results
+          
             self._log("Getting final response after tool calls")
             final_response = get_litellm_response(
                 model=self.model,
@@ -296,7 +296,7 @@ class MCPClient:
             
             final_text.append(final_response.get("response", ""))
             
-            # Update messages with final assistant response
+          
             current_messages.append({
                 "role": "assistant",
                 "content": final_response.get("response", "")
@@ -320,11 +320,11 @@ class MCPClient:
             if query.lower() == 'quit':
                 break
             
-            # Process the query
+          
             result = await self.process_query(query, messages)
             messages = result.get("messages", [])
             
-            # Display the response
+          
             print("\nResponse:")
             print(result.get("response", ""))
 
@@ -341,16 +341,16 @@ async def main():
         
     server_script = sys.argv[1]
     
-    # Create and configure the client
+  
     client = MCPClient()
     
-    # Connect to the server
+  
     await client.connect_to_server(server_script)
     
-    # Run the interactive chat loop
+  
     await client.chat_loop()
     
-    # Clean up resources
+  
     await client.cleanup()
 
 if __name__ == "__main__":

npcsh/mcp_server.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+
 """
 Enhanced MCP server that incorporates functionality from npcpy.routes, 
 npcpy.llm_funcs, and npcpy.npc_compiler as tools.
@@ -10,10 +10,10 @@ import json
 import asyncio
 
 from typing import Optional, Dict, Any, List, Union, Callable
-# MCP imports
+
 from mcp.server.fastmcp import FastMCP
 import importlib
-# npcpy imports
+
 
 
 import os
@@ -25,7 +25,7 @@ try:
 except: 
     pass
 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 
 
@@ -40,14 +40,13 @@ from npcsh._state import NPCSH_DB_PATH
 
 command_history = CommandHistory(db=NPCSH_DB_PATH)
 
-# Initialize the MCP server
 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:
     """
@@ -66,7 +65,7 @@ async def run_server_command(command: str) -> str:
             shell=True, 
             capture_output=True, 
             text=True,
-            timeout=30  # Add timeout to prevent hanging
+            timeout=30
         )
         return result.stdout or result.stderr or "Command completed with no output"
     except subprocess.TimeoutExpired:
@@ -109,15 +108,15 @@ def register_module_tools(module_name: str) -> None:
     """
     functions = load_module_functions(module_name)
     for func in functions:
-        # Skip functions that don't have docstrings
+      
         if not func.__doc__:
             print(f"Skipping function without docstring: {func.__name__}")
             continue
             
-        # Create async wrapper with improved argument handling
+      
         async_func = make_async_wrapper(func)
         
-        # Register as MCP tool
+      
         try:
             mcp.tool()(async_func)
             print(f"Registered tool: {func.__name__}")
@@ -129,11 +128,11 @@ def load_module_functions(module_name: str) -> List[Callable]:
     """
     try:
         module = importlib.import_module(module_name)
-        # Get all callables from the module that don't start with underscore
+      
         functions = []
         for name, func in inspect.getmembers(module, callable):
             if not name.startswith('_'):
-                # Check if it's a function, not a class
+              
                 if inspect.isfunction(func) or inspect.ismethod(func):
                     functions.append(func)
         return functions
@@ -159,13 +158,13 @@ def register_selected_npcpy_tools():
              search_web, ]
 
     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__
+                pass
 
         try:
             async_func = make_async_wrapper(func)
@@ -178,11 +177,11 @@ register_selected_npcpy_tools()
 
 
 
-# ==================== MAIN ENTRY POINT ====================
+
 
 if __name__ == "__main__":
     print(f"Starting enhanced NPCPY MCP server...")
     print(f"Workspace: {DEFAULT_WORKSPACE}")
     
-    # Run the server
+  
     mcp.run(transport="stdio")

npcsh/npc.py

@@ -21,7 +21,6 @@ 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,
@@ -75,7 +74,7 @@ def main():
         "-n", "--npc", help="Name of the NPC to use (default: sibiji)", type=str, default="sibiji"
     )
 
-    # Parse arguments
+  
     args, all_args = parser.parse_known_args()
     global_model = args.model
     global_provider = args.provider
@@ -105,12 +104,12 @@ def main():
             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.lstrip('/')] + all_args)
         command_args = args.command_args if hasattr(args, 'command_args') else []
         unknown_args = []
     else:
-        # Treat all arguments as a prompt
+      
         args.command = None
         command_args = []
         unknown_args = all_args
@@ -120,7 +119,7 @@ def main():
     if args.provider is None:
         args.provider = global_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:
@@ -129,7 +128,7 @@ def main():
         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]
@@ -142,11 +141,11 @@ def main():
         print(f"Error: Could not load NPC '{args.npc}'", file=sys.stderr)
         sys.exit(1)
 
-    # 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]
         
-        # Check if first argument is a jinx name
+      
         jinx_found = False
         if team and first_arg in team.jinxs_dict:
             jinx_found = True
@@ -158,25 +157,25 @@ def main():
             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)
@@ -191,7 +190,7 @@ def main():
                 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)
@@ -207,21 +206,21 @@ def main():
                 print(f"Command '{command_name}' executed.")
 
         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)
 
             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)
 
-            # Process and display the result
+          
             if isinstance(result, dict):
                 output = result.get("output")
                 model_for_stream = result.get('model', effective_model)

npcsh/npc_team/jinxs/bash_executer.jinx

@@ -8,7 +8,7 @@ steps:
     code: |
       import subprocess
       import os
-      cmd = '{{bash_command}}'  # Properly quote the command input
+      cmd = '{{bash_command}}'
       def run_command(cmd):
         process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         stdout, stderr = process.communicate()

npcsh/npc_team/jinxs/edit_file.jinx

@@ -12,23 +12,23 @@ steps:
       import os
       from npcpy.llm_funcs import get_llm_response
       
-      # Get inputs
+    
       file_path = os.path.expanduser("{{ file_path }}")
       edit_instructions = "{{ edit_instructions }}"
       backup_str = "{{ backup }}"
       create_backup = backup_str.lower() not in ('false', 'no', '0', '')
       
-      # Read file content
+    
       with open(file_path, 'r') as f:
           original_content = f.read()
       
-      # Create backup if requested
+    
       if create_backup:
           backup_path = file_path + ".bak"
           with open(backup_path, 'w') as f:
               f.write(original_content)
       
-      # Make the prompt for the LLM
+    
       prompt = """You are a code editing assistant. Analyze this file and make the requested changes.
 
         File content:
@@ -46,14 +46,14 @@ steps:
         - "insertion": For "insert_after" and "insert_before", the text to insert
         2. "explanation": Brief explanation of the changes made
         """
-      # Get the LLM response with JSON formatting
+    
       response = get_llm_response(prompt, model=npc.model, provider=npc.provider, npc=npc, format="json")
       
       result = response.get("response", {})
       modifications = result.get("modifications", [])
       explanation = result.get("explanation", "No explanation provided")
       
-      # Apply modifications
+    
       updated_content = original_content
       changes_applied = 0
       

npcsh/npc_team/jinxs/image_generation.jinx

@@ -10,20 +10,20 @@ steps:
     code: |
       image_prompt = '{{prompt}}'.strip()
       from npcpy.llm_funcs import gen_image
-      # Generate the image
+    
       pil_image = gen_image(
           image_prompt,
           npc=npc,
-          model='{{model}}',  # You can adjust the model as needed
+          model='{{model}}',
           provider='{{provider}}'
       )
       if pil_image:
           image_generated = True
       else:
           image_generated = False
-      # save the image 
+    
       output_name = '{{output_name}}'
       pil_image.save(f'{output_name}.png')
-      # open the image to display it
-      #pil_image.show()
+    
+    
       output = output_name

npcsh/npc_team/jinxs/screen_cap.jinx

@@ -9,8 +9,8 @@ steps:
       from npcpy.data.image import capture_screenshot
       out = capture_screenshot(full=True)
       prompt = "{{prompt}}"
-      # Now properly use get_llm_response to analyze the image
-      # Create a prompt that includes the user's request and instructions
+    
+    
       analysis_prompt = prompt + "\n\nAttached is a screenshot of my screen currently. Please use this to evaluate the situation. If the user asked for you to explain what's on their screen or something similar, they are referring to the details contained within the attached image."
       llm_response = get_llm_response(
           prompt=analysis_prompt,

npcsh/npcsh.py

@@ -68,7 +68,10 @@ Begin by asking a question, issuing a bash command, or typing '/help' for more i
         )
 
 
+
 def run_repl(command_history: CommandHistory, initial_state: ShellState):
+    
+
     '''
     Func for running the npcsh repl    
     '''
@@ -137,7 +140,7 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState):
 
                 )
                 
-                # Save the updated KG back to the database under the same exact scope
+              
                 save_kg_to_db(engine,
                               evolved_kg,
                               team_name, 
@@ -181,7 +184,7 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState):
                 prompt = readline_safe_prompt(f"{cwd_colored}{prompt_end}")
 
             user_input = get_multiline_input(prompt).strip()
-            # Handle Ctrl+Z (ASCII SUB, '\x1a') as exit (Windows and Unix)
+          
             if user_input == "\x1a":
                 exit_shell(state)