npcsh 1.1.12__py3-none-any.whl → 1.1.14__py3-none-any.whl

npcsh/npc_team/jinxs/code/sh.jinx

@@ -7,28 +7,24 @@ steps:
     engine: python
     code: |
       import subprocess
-      import sys # Import sys to explicitly write to stderr for visibility
-
-      # Force a simple print to see if anything comes out
-      print("--- Jinx 'sh' code started ---", file=sys.stderr) 
+      import os
 
       cmd = '{{ bash_command }}'
-      
-      # Initialize output to an empty string to ensure it always exists
-      output = "" 
-
+      output = ""
 
       process = subprocess.Popen(
-          cmd, 
-          shell=True, 
-          stdout=subprocess.PIPE, 
+          cmd,
+          shell=True,
+          stdout=subprocess.PIPE,
           stderr=subprocess.PIPE
       )
       stdout, stderr = process.communicate()
-      
-      # Print raw stdout/stderr to sys.stderr for better visibility in some environments
-      print(f"Jinx 'sh' raw stdout: {stdout.decode('utf-8', errors='ignore')}", file=sys.stderr)
-      print(f"Jinx 'sh' raw stderr: {stderr.decode('utf-8', errors='ignore')}", file=sys.stderr)
+
+      # Only show debug output if NPCSH_DEBUG is set
+      if os.environ.get("NPCSH_DEBUG") == "1":
+          import sys
+          print(f"[sh] cmd: {cmd}", file=sys.stderr)
+          print(f"[sh] stdout: {stdout.decode('utf-8', errors='ignore')[:200]}", file=sys.stderr)
 
       if stderr:
           output = f"Error: {stderr.decode('utf-8')}"

npcsh/npc_team/jinxs/modes/alicanto.jinx

@@ -1,88 +1,194 @@
-jinx_name: "alicanto"
-description: "Conduct deep research with multiple perspectives, identifying gold insights and cliff warnings"
+jinx_name: alicanto
+description: Deep research mode - multi-perspective exploration with gold insights and cliff warnings
+npc: forenpc
 inputs:
-  - query: "" # Required research query.
-  - num_npcs: 5 # Number of NPCs to involve in research.
-  - depth: 3 # Depth of research.
-  - model: "" # LLM model to use. Defaults to NPCSH_CHAT_MODEL or NPC's model.
-  - provider: "" # LLM provider to use. Defaults to NPCSH_CHAT_PROVIDER or NPC's provider.
-  - max_steps: 20 # Maximum number of steps in Alicanto research.
-  - skip_research: True # Whether to skip the research phase.
-  - exploration: "" # Exploration factor (float).
-  - creativity: "" # Creativity factor (float).
-  - format: "" # Output format (report, summary, full).
+  - query: null
+  - num_npcs: 5
+  - depth: 3
+  - model: null
+  - provider: null
+  - max_steps: 20
+  - skip_research: true
+  - exploration: 0.3
+  - creativity: 0.5
+  - format: report
+
 steps:
-  - name: "conduct_alicanto_research"
-    engine: "python"
+  - name: alicanto_research
+    engine: python
     code: |
-      import traceback
-      import logging
-      from npcsh.alicanto import alicanto
-      # Assuming NPCSH_CHAT_MODEL and NPCSH_CHAT_PROVIDER are accessible
+      import os
+      from termcolor import colored
+
+      from npcpy.llm_funcs import get_llm_response
+      from npcpy.data.web import search_web
+      from npcpy.npc_compiler import NPC
+
+      npc = context.get('npc')
+      team = context.get('team')
+      messages = context.get('messages', [])
 
       query = context.get('query')
-      num_npcs = int(context.get('num_npcs', 5)) # Ensure int type
-      depth = int(context.get('depth', 3)) # Ensure int type
-      llm_model = context.get('model')
-      llm_provider = context.get('provider')
-      max_steps = int(context.get('max_steps', 20)) # Ensure int type
+      num_npcs = int(context.get('num_npcs', 5))
+      depth = int(context.get('depth', 3))
+      max_steps = int(context.get('max_steps', 20))
       skip_research = context.get('skip_research', True)
-      exploration_factor = context.get('exploration')
-      creativity_factor = context.get('creativity')
-      output_format = context.get('format')
-      output_messages = context.get('messages', [])
-      current_npc = context.get('npc')
-      
-      if not query or not query.strip():
-          context['output'] = "Usage: /alicanto <research query> [--num-npcs N] [--depth N] [--exploration 0.3] [--creativity 0.5] [--format report|summary|full]"
-          context['messages'] = output_messages
+      exploration = float(context.get('exploration', 0.3))
+      creativity = float(context.get('creativity', 0.5))
+      output_format = context.get('format', 'report')
+
+      model = context.get('model') or (npc.model if npc else 'gemini-1.5-pro')
+      provider = context.get('provider') or (npc.provider if npc else 'gemini')
+
+      if not query:
+          context['output'] = """Usage: /alicanto <research query>
+
+      Options:
+        --num-npcs N      Number of research perspectives (default: 5)
+        --depth N         Research depth (default: 3)
+        --max-steps N     Maximum research steps (default: 20)
+        --exploration F   Exploration factor 0-1 (default: 0.3)
+        --creativity F    Creativity factor 0-1 (default: 0.5)
+        --format FORMAT   Output: report|summary|full (default: report)
+
+      Example: /alicanto What are the latest advances in quantum computing?"""
+          context['messages'] = messages
           exit()
 
-      # Fallback for model/provider if not explicitly set in Jinx inputs
-      if not llm_model and current_npc and current_npc.model:
-          llm_model = current_npc.model
-      if not llm_provider and current_npc and current_npc.provider:
-          llm_provider = current_npc.provider
-      
-      # Final fallbacks (these would ideally come from npcsh._state config)
-      # Assuming NPCSH_CHAT_MODEL and NPCSH_CHAT_PROVIDER exist and are imported implicitly or set by environment
-      # Hardcoding defaults for demonstration if not available through NPC or _state
-      if not llm_model: llm_model = "gemini-1.5-pro" 
-      if not llm_provider: llm_provider = "gemini" 
-
-      try:
-          logging.info(f"Starting Alicanto research on: {query}")
-
-          alicanto_kwargs = {
-              'query': query,
-              'num_npcs': num_npcs,
-              'depth': depth,
-              'model': llm_model,
-              'provider': llm_provider, 
-              'max_steps': max_steps,
-              'skip_research': skip_research,
-          }
-
-          if exploration_factor: alicanto_kwargs['exploration_factor'] = float(exploration_factor)
-          if creativity_factor: alicanto_kwargs['creativity_factor'] = float(creativity_factor)
-          if output_format: alicanto_kwargs['output_format'] = output_format
-
-          result = alicanto(**alicanto_kwargs)
-          
-          output_result = ""
-          if isinstance(result, dict):
-              if "integration" in result:
-                  output_result = result["integration"]
-              else:
-                  output_result = "Alicanto research completed. Full results available in returned data."
-          else:
-              output_result = str(result)
-              
-          context['output'] = output_result
-          context['messages'] = output_messages
-          context['alicanto_result'] = result # Store full result in context
-      except Exception as e:
-          traceback.print_exc()
-          logging.error(f"Error during Alicanto research: {e}")
-          context['output'] = f"Error during Alicanto research: {e}"
-          context['messages'] = output_messages
+      print(f"""
+       █████╗ ██╗     ██╗ ██████╗ █████╗ ███╗   ██╗████████╗ ██████╗
+      ██╔══██╗██║     ██║██╔════╝██╔══██╗████╗  ██║╚══██╔══╝██╔═══██╗
+      ███████║██║     ██║██║     ███████║██╔██╗ ██║   ██║   ██║   ██║
+      ██╔══██║██║     ██║██║     ██╔══██║██║╚██╗██║   ██║   ██║   ██║
+      ██║  ██║███████╗██║╚██████╗██║  ██║██║ ╚████║   ██║   ╚██████╔╝
+      ╚═╝  ╚═╝╚══════╝╚═╝ ╚═════╝╚═╝  ╚═╝╚═╝  ╚═══╝   ╚═╝    ╚═════╝
+
+      Deep Research Mode
+      Query: {query}
+      Perspectives: {num_npcs} | Depth: {depth} | Max Steps: {max_steps}
+      """)
+
+      # Generate research perspectives
+      perspectives_prompt = f"""Generate {num_npcs} distinct research perspectives for investigating: "{query}"
+
+      For each perspective, provide:
+      1. Name (a descriptive title)
+      2. Approach (how this perspective would investigate)
+      3. Key questions to explore
+
+      Return as a numbered list."""
+
+      print(colored("Generating research perspectives...", "cyan"))
+      resp = get_llm_response(
+          perspectives_prompt,
+          model=model,
+          provider=provider,
+          npc=npc
+      )
+      perspectives = str(resp.get('response', ''))
+      print(perspectives)
+
+      # Conduct web research if not skipped
+      research_findings = ""
+      if not skip_research:
+          print(colored("\nConducting web research...", "cyan"))
+          try:
+              search_results = search_web(query, n_results=5)
+              if search_results:
+                  research_findings = "\n\nWeb Research Findings:\n"
+                  for i, result in enumerate(search_results[:5], 1):
+                      title = result.get('title', 'No title')
+                      snippet = result.get('snippet', result.get('body', ''))[:200]
+                      research_findings += f"\n{i}. {title}\n   {snippet}...\n"
+                  print(colored(f"Found {len(search_results)} sources", "green"))
+          except Exception as e:
+              print(colored(f"Web search error: {e}", "yellow"))
+
+      # Multi-step exploration from each perspective
+      all_insights = []
+      gold_insights = []  # Key valuable findings
+      cliff_warnings = []  # Potential pitfalls or caveats
+
+      for step in range(min(depth, max_steps)):
+          print(colored(f"\n--- Research Depth {step + 1}/{depth} ---", "cyan"))
+
+          explore_prompt = f"""Research query: "{query}"
+
+      Perspectives generated:
+      {perspectives}
+
+      {research_findings}
+
+      Previous insights: {all_insights[-3:] if all_insights else 'None yet'}
+
+      For depth level {step + 1}:
+      1. Explore deeper implications from each perspective
+      2. Identify GOLD insights (valuable, non-obvious findings) - mark with [GOLD]
+      3. Identify CLIFF warnings (pitfalls, caveats, risks) - mark with [CLIFF]
+      4. Connect insights across perspectives
+
+      Exploration factor: {exploration} (higher = more diverse exploration)
+      Creativity factor: {creativity} (higher = more novel connections)"""
+
+          resp = get_llm_response(
+              explore_prompt,
+              model=model,
+              provider=provider,
+              temperature=creativity,
+              npc=npc
+          )
+
+          step_insights = str(resp.get('response', ''))
+          print(step_insights)
+
+          # Extract gold and cliff markers
+          if '[GOLD]' in step_insights:
+              gold_insights.extend([line.strip() for line in step_insights.split('\n') if '[GOLD]' in line])
+          if '[CLIFF]' in step_insights:
+              cliff_warnings.extend([line.strip() for line in step_insights.split('\n') if '[CLIFF]' in line])
+
+          all_insights.append(step_insights)
+
+      # Generate final synthesis
+      print(colored("\n--- Synthesizing Research ---", "cyan"))
+
+      synthesis_prompt = f"""Synthesize research on: "{query}"
+
+      All insights gathered:
+      {chr(10).join(all_insights)}
+
+      Gold insights identified:
+      {chr(10).join(gold_insights) if gold_insights else 'None explicitly marked'}
+
+      Cliff warnings identified:
+      {chr(10).join(cliff_warnings) if cliff_warnings else 'None explicitly marked'}
+
+      Generate a {output_format} that:
+      1. Summarizes key findings
+      2. Highlights the most valuable insights (gold)
+      3. Notes important caveats and risks (cliffs)
+      4. Provides actionable conclusions"""
+
+      resp = get_llm_response(
+          synthesis_prompt,
+          model=model,
+          provider=provider,
+          npc=npc
+      )
+
+      final_report = str(resp.get('response', ''))
+      print("\n" + "="*60)
+      print(colored("ALICANTO RESEARCH REPORT", "green", attrs=['bold']))
+      print("="*60)
+      print(final_report)
+
+      context['output'] = final_report
+      context['messages'] = messages
+      context['alicanto_result'] = {
+          'query': query,
+          'perspectives': perspectives,
+          'insights': all_insights,
+          'gold': gold_insights,
+          'cliffs': cliff_warnings,
+          'report': final_report
+      }

npcsh/npc_team/jinxs/modes/corca.jinx

@@ -1,28 +1,249 @@
-jinx_name: "corca"
-description: "Enter the Corca MCP-powered agentic shell"
+jinx_name: corca
+description: MCP-powered agentic shell - LLM with tool use via MCP servers
 inputs:
-  - mcp_server_path: '~/.npcsh/npc_team/mcp_server.py'
-  - force_global: false
+  - mcp_server_path: null
   - initial_command: null
+  - model: null
+  - provider: null
+
 steps:
-  - name: "enter_corca"
-    engine: "python"
+  - name: corca_repl
+    engine: python
     code: |
-      from npcsh._state import setup_shell 
-      from npcsh.corca import corca_session
-      
+      import os
+      import sys
+      import asyncio
+      import json
+      from contextlib import AsyncExitStack
+      from termcolor import colored
+
+      from npcpy.llm_funcs import get_llm_response
+      from npcpy.npc_sysenv import render_markdown, get_system_message
+
+      # MCP imports
+      try:
+          from mcp import ClientSession, StdioServerParameters
+          from mcp.client.stdio import stdio_client
+          MCP_AVAILABLE = True
+      except ImportError:
+          MCP_AVAILABLE = False
+          print(colored("MCP not available. Install with: pip install mcp-client", "yellow"))
+
+      npc = context.get('npc')
+      team = context.get('team')
+      messages = context.get('messages', [])
       mcp_server_path = context.get('mcp_server_path')
-      force_global = context.get('force_global', False)
       initial_command = context.get('initial_command')
-      
-      command_history, _, _ = setup_shell()
-      
-      result = corca_session(
-          command_history=command_history,
-          mcp_server_path=mcp_server_path,
-          force_global=force_global,
-          initial_command=initial_command
-      )
-      
-      context['output'] = result.get('output', 'Exited Corca mode.')
-      context['messages'] = result.get('messages', [])
+
+      model = context.get('model') or (npc.model if npc else None)
+      provider = context.get('provider') or (npc.provider if npc else None)
+
+      # Use shared_context for MCP state
+      shared_ctx = npc.shared_context if npc and hasattr(npc, 'shared_context') else {}
+
+      print("""
+       ██████╗ ██████╗ ██████╗  ██████╗ █████╗
+      ██╔════╝██╔═══██╗██╔══██╗██╔════╝██╔══██╗
+      ██║     ██║   ██║██████╔╝██║     ███████║
+      ██║     ██║   ██║██╔══██╗██║     ██╔══██╗
+      ╚██████╗╚██████╔╝██║  ██║╚██████╗██║  ██║
+       ╚═════╝ ╚═════╝ ╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝
+      """)
+
+      npc_name = npc.name if npc else "corca"
+      print(f"Entering corca mode (NPC: {npc_name}). Type '/cq' to exit.")
+
+      # ========== MCP Connection Setup ==========
+      async def connect_mcp(server_path):
+          """Connect to MCP server and return tools"""
+          if not MCP_AVAILABLE:
+              return [], {}
+
+          abs_path = os.path.abspath(os.path.expanduser(server_path))
+          if not os.path.exists(abs_path):
+              print(colored(f"MCP server not found: {abs_path}", "red"))
+              return [], {}
+
+          try:
+              loop = asyncio.get_event_loop()
+          except RuntimeError:
+              loop = asyncio.new_event_loop()
+              asyncio.set_event_loop(loop)
+
+          exit_stack = AsyncExitStack()
+
+          if abs_path.endswith('.py'):
+              cmd_parts = [sys.executable, abs_path]
+          else:
+              cmd_parts = [abs_path]
+
+          server_params = StdioServerParameters(
+              command=cmd_parts[0],
+              args=[abs_path],
+              env=os.environ.copy()
+          )
+
+          stdio_transport = await exit_stack.enter_async_context(stdio_client(server_params))
+          session = await exit_stack.enter_async_context(ClientSession(*stdio_transport))
+          await session.initialize()
+
+          response = await session.list_tools()
+          tools_llm = []
+          tool_map = {}
+
+          if response.tools:
+              for mcp_tool in response.tools:
+                  tool_def = {
+                      "type": "function",
+                      "function": {
+                          "name": mcp_tool.name,
+                          "description": mcp_tool.description or f"MCP tool: {mcp_tool.name}",
+                          "parameters": getattr(mcp_tool, "inputSchema", {"type": "object", "properties": {}})
+                      }
+                  }
+                  tools_llm.append(tool_def)
+
+                  # Create sync wrapper for async tool call
+                  def make_tool_func(tool_name, sess, lp):
+                      async def call_tool(**kwargs):
+                          cleaned = {k: (None if v == 'None' else v) for k, v in kwargs.items()}
+                          result = await asyncio.wait_for(sess.call_tool(tool_name, cleaned), timeout=30.0)
+                          return result
+                      def sync_call(**kwargs):
+                          return lp.run_until_complete(call_tool(**kwargs))
+                      return sync_call
+
+                  tool_map[mcp_tool.name] = make_tool_func(mcp_tool.name, session, loop)
+
+          # Store in shared context
+          shared_ctx['mcp_client'] = session
+          shared_ctx['mcp_tools'] = tools_llm
+          shared_ctx['mcp_tool_map'] = tool_map
+          shared_ctx['_mcp_exit_stack'] = exit_stack
+          shared_ctx['_mcp_loop'] = loop
+
+          print(colored(f"Connected to MCP server. Tools: {', '.join(tool_map.keys())}", "green"))
+          return tools_llm, tool_map
+
+      # Try to connect if server path provided
+      tools_llm = shared_ctx.get('mcp_tools', [])
+      tool_map = shared_ctx.get('mcp_tool_map', {})
+
+      if mcp_server_path and not tools_llm:
+          try:
+              loop = asyncio.get_event_loop()
+          except RuntimeError:
+              loop = asyncio.new_event_loop()
+              asyncio.set_event_loop(loop)
+          tools_llm, tool_map = loop.run_until_complete(connect_mcp(mcp_server_path))
+
+      # Find default MCP server if none provided
+      if not tools_llm:
+          default_paths = [
+              os.path.expanduser("~/.npcsh/npc_team/mcp_server.py"),
+              os.path.join(team.team_path, "mcp_server.py") if team and hasattr(team, 'team_path') else None,
+          ]
+          for path in default_paths:
+              if path and os.path.exists(path):
+                  try:
+                      loop = asyncio.get_event_loop()
+                  except RuntimeError:
+                      loop = asyncio.new_event_loop()
+                      asyncio.set_event_loop(loop)
+                  tools_llm, tool_map = loop.run_until_complete(connect_mcp(path))
+                  if tools_llm:
+                      break
+
+      # Ensure system message
+      if not messages or messages[0].get("role") != "system":
+          sys_msg = get_system_message(npc) if npc else "You are an AI assistant with access to tools."
+          if tools_llm:
+              sys_msg += f"\n\nYou have access to these tools: {', '.join(t['function']['name'] for t in tools_llm)}"
+          messages.insert(0, {"role": "system", "content": sys_msg})
+
+      # Handle initial command if provided (one-shot mode)
+      if initial_command:
+          resp = get_llm_response(
+              initial_command,
+              model=model,
+              provider=provider,
+              messages=messages,
+              tools=tools_llm if tools_llm else None,
+              tool_map=tool_map if tool_map else None,
+              auto_process_tool_calls=True,
+              npc=npc
+          )
+          messages = resp.get('messages', messages)
+          render_markdown(str(resp.get('response', '')))
+          context['output'] = resp.get('response', 'Done.')
+          context['messages'] = messages
+          # Don't enter REPL for one-shot
+          exit()
+
+      # REPL loop
+      while True:
+          try:
+              prompt_str = f"{npc_name}:corca> "
+              user_input = input(prompt_str).strip()
+
+              if not user_input:
+                  continue
+
+              if user_input.lower() == "/cq":
+                  print("Exiting corca mode.")
+                  break
+
+              # Handle /tools to list available tools
+              if user_input.lower() == "/tools":
+                  if tools_llm:
+                      print(colored("Available MCP tools:", "cyan"))
+                      for t in tools_llm:
+                          print(f"  - {t['function']['name']}: {t['function'].get('description', '')[:60]}")
+                  else:
+                      print(colored("No MCP tools connected.", "yellow"))
+                  continue
+
+              # Handle /connect to connect to new MCP server
+              if user_input.startswith("/connect "):
+                  new_path = user_input[9:].strip()
+                  try:
+                      loop = asyncio.get_event_loop()
+                  except RuntimeError:
+                      loop = asyncio.new_event_loop()
+                      asyncio.set_event_loop(loop)
+                  tools_llm, tool_map = loop.run_until_complete(connect_mcp(new_path))
+                  continue
+
+              # Get LLM response with tools
+              resp = get_llm_response(
+                  user_input,
+                  model=model,
+                  provider=provider,
+                  messages=messages,
+                  tools=tools_llm if tools_llm else None,
+                  tool_map=tool_map if tool_map else None,
+                  auto_process_tool_calls=True,
+                  stream=False,  # Tool calls don't work well with streaming
+                  npc=npc
+              )
+
+              messages = resp.get('messages', messages)
+              response_text = resp.get('response', '')
+              render_markdown(str(response_text))
+
+              # Track usage
+              if 'usage' in resp and npc and hasattr(npc, 'shared_context'):
+                  usage = resp['usage']
+                  npc.shared_context['session_input_tokens'] += usage.get('input_tokens', 0)
+                  npc.shared_context['session_output_tokens'] += usage.get('output_tokens', 0)
+                  npc.shared_context['turn_count'] += 1
+
+          except KeyboardInterrupt:
+              print("\nUse '/cq' to exit or continue.")
+              continue
+          except EOFError:
+              print("\nExiting corca mode.")
+              break
+
+      context['output'] = "Exited corca mode."
+      context['messages'] = messages