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

npcsh/npc_team/jinxs/modes/pti.jinx

@@ -1,28 +1,170 @@
-jinx_name: "pti"
-description: "Enter Pardon-The-Interruption mode for human-in-the-loop reasoning."
+jinx_name: pti
+description: Pardon-The-Interruption - human-in-the-loop reasoning with think tags and interruptible streaming
+npc: frederic
 inputs:
-  - command_args: "" # The full command string or specific arguments for PTI mode.
+  - model: null
+  - provider: null
+  - files: null
+  - reasoning_model: null
+
 steps:
-  - name: "enter_pti"
-    engine: "python"
+  - name: pti_repl
+    engine: python
     code: |
-      import traceback
-      from npcsh.pti import enter_pti_mode
-      
-      command_args = context.get('command_args', '') # The full command string from router
-      output_messages = context.get('messages', [])
-      
-      try:
-          # enter_pti_mode likely expects the full command string for its own parsing
-          result = enter_pti_mode(command=command_args, **context)
-          
-          if isinstance(result, dict):
-              context['output'] = result.get('output', 'Entered PTI mode.')
-              context['messages'] = result.get('messages', output_messages)
-          else:
-              context['output'] = str(result)
-              context['messages'] = output_messages
-      except Exception as e:
-          traceback.print_exc()
-          context['output'] = f"Error entering pti mode: {e}"
-          context['messages'] = output_messages
+      import os
+      import sys
+      from termcolor import colored
+
+      from npcpy.llm_funcs import get_llm_response
+      from npcpy.npc_sysenv import get_system_message, render_markdown
+      from npcpy.data.load import load_file_contents
+      from npcpy.data.text import rag_search
+
+      npc = context.get('npc')
+      team = context.get('team')
+      messages = context.get('messages', [])
+      files = context.get('files')
+
+      # PTI uses reasoning model for deeper thinking
+      model = context.get('reasoning_model') or context.get('model') or (npc.model if npc else None)
+      provider = context.get('provider') or (npc.provider if npc else None)
+
+      print("""
+      ██████╗ ████████╗██╗
+      ██╔══██╗╚══██╔══╝██║
+      ██████╔╝   ██║   ██║
+      ██╔═══╝    ██║   ██║
+      ██║        ██║   ██║
+      ╚═╝        ╚═╝   ╚═╝
+
+      Pardon-The-Interruption
+      Human-in-the-loop reasoning mode
+      """)
+
+      npc_name = npc.name if npc else "pti"
+      print(f"Entering PTI mode (NPC: {npc_name}). Type '/pq' to exit.")
+      print("  - AI will use <think> tags for step-by-step reasoning")
+      print("  - Use <request_for_input> to pause and ask questions")
+      print("  - Ctrl+C interrupts stream for immediate feedback")
+
+      # Load files if provided
+      loaded_content = {}
+      if files:
+          if isinstance(files, str):
+              files = [f.strip() for f in files.split(',')]
+          for file_path in files:
+              file_path = os.path.expanduser(file_path)
+              if os.path.exists(file_path):
+                  try:
+                      chunks = load_file_contents(file_path)
+                      loaded_content[file_path] = "\n".join(chunks)
+                      print(colored(f"Loaded: {file_path}", "green"))
+                  except Exception as e:
+                      print(colored(f"Error loading {file_path}: {e}", "red"))
+
+      # System message for PTI mode
+      pti_system = """You are an AI assistant in PTI (Pardon-The-Interruption) mode.
+
+      IMPORTANT INSTRUCTIONS:
+      1. Think step-by-step using <think>...</think> tags to show your reasoning
+      2. When you need more information from the user, use <request_for_input>your question</request_for_input>
+      3. Be thorough but concise in your reasoning
+      4. The user can interrupt at any time to provide guidance
+
+      Example:
+      <think>
+      Let me break this down...
+      Step 1: First I need to understand X
+      Step 2: Then consider Y
+      </think>
+
+      <request_for_input>
+      I notice you mentioned Z. Could you clarify what you mean by that?
+      </request_for_input>"""
+
+      if not messages or messages[0].get("role") != "system":
+          messages.insert(0, {"role": "system", "content": pti_system})
+
+      # REPL loop
+      user_input = None
+      while True:
+          try:
+              if not user_input:
+                  prompt_str = f"{npc_name}:pti> "
+                  user_input = input(prompt_str).strip()
+
+              if not user_input:
+                  user_input = None
+                  continue
+
+              if user_input.lower() == "/pq":
+                  print("Exiting PTI mode.")
+                  break
+
+              # Build prompt with file context
+              prompt_for_llm = user_input
+              if loaded_content:
+                  context_str = "\n".join([f"--- {fname} ---\n{content}" for fname, content in loaded_content.items()])
+                  prompt_for_llm += f"\n\nContext:\n{context_str}"
+
+              prompt_for_llm += "\n\nThink step-by-step using <think> tags. Use <request_for_input> when you need clarification."
+
+              messages.append({"role": "user", "content": user_input})
+
+              try:
+                  resp = get_llm_response(
+                      prompt_for_llm,
+                      model=model,
+                      provider=provider,
+                      messages=messages[:-1],  # Don't duplicate the user message
+                      stream=True,
+                      npc=npc
+                  )
+
+                  response_stream = resp.get('response')
+                  full_response = ""
+                  request_found = False
+
+                  # Stream the response
+                  for chunk in response_stream:
+                      chunk_content = ""
+                      if hasattr(chunk, 'choices') and chunk.choices:
+                          delta = chunk.choices[0].delta
+                          if hasattr(delta, 'content') and delta.content:
+                              chunk_content = delta.content
+                      elif isinstance(chunk, dict):
+                          chunk_content = chunk.get("message", {}).get("content", "")
+
+                      if chunk_content:
+                          print(chunk_content, end='', flush=True)
+                          full_response += chunk_content
+
+                          # Check for request_for_input
+                          if "</request_for_input>" in full_response:
+                              request_found = True
+                              break
+
+                  print()  # newline after stream
+
+                  messages.append({"role": "assistant", "content": full_response})
+                  user_input = None  # Reset for next iteration
+
+              except KeyboardInterrupt:
+                  print(colored("\n\n--- Interrupted ---", "yellow"))
+                  interrupt_input = input("Your feedback: ").strip()
+                  if interrupt_input:
+                      user_input = interrupt_input
+                  else:
+                      user_input = None
+                  continue
+
+          except KeyboardInterrupt:
+              print("\nUse '/pq' to exit or continue.")
+              user_input = None
+              continue
+          except EOFError:
+              print("\nExiting PTI mode.")
+              break
+
+      context['output'] = "Exited PTI mode."
+      context['messages'] = messages

npcsh/npc_team/jinxs/modes/spool.jinx

@@ -1,40 +1,161 @@
-jinx_name: "spool"
-description: "Enter interactive chat (spool) mode"
-inputs: [] # Spool mode typically takes its parameters directly from the environment/kwargs
+jinx_name: spool
+description: Interactive chat mode - simple conversational interface with an NPC
+inputs:
+  - model: null
+  - provider: null
+  - attachments: null
+  - stream: true
+
 steps:
-  - name: "enter_spool"
-    engine: "python"
+  - name: spool_repl
+    engine: python
     code: |
-      import traceback
-      from npcpy.npc_compiler import NPC, Team
-      from npcsh.spool import enter_spool_mode
-      
-      output_messages = context.get('messages', [])
-      current_npc = context.get('npc')
-      current_team = context.get('team')
-
-      try:
-          # Handle potential string NPC name if passed from CLI
-          if isinstance(current_npc, str) and current_team:
-              npc_name = current_npc
-              if npc_name in current_team.npcs:
-                  current_npc = current_team.npcs[npc_name]
+      import os
+      import sys
+      from termcolor import colored
+
+      from npcpy.llm_funcs import get_llm_response
+      from npcpy.npc_sysenv import get_system_message, render_markdown
+      from npcpy.data.load import load_file_contents
+      from npcpy.data.text import rag_search
+
+      npc = context.get('npc')
+      team = context.get('team')
+      messages = context.get('messages', [])
+      stream = context.get('stream', True)
+      attachments = context.get('attachments')
+
+      # Use NPC's model/provider or fallback
+      model = context.get('model') or (npc.model if npc else None)
+      provider = context.get('provider') or (npc.provider if npc else None)
+
+      # ASCII art
+      print("""
+       _____ ____   ____   ____  _
+      / ___/|  _ \ / __ \ / __ \| |
+      \___ \| |_) | |  | | |  | | |
+       ___) |  __/| |  | | |  | | |___
+      |____/|_|    \____/ \____/|_____|
+      """)
+
+      npc_name = npc.name if npc else "chat"
+      print(f"Entering spool mode (NPC: {npc_name}). Type '/sq' to exit.")
+
+      # Load attachments if provided
+      loaded_chunks = {}
+      if attachments:
+          if isinstance(attachments, str):
+              attachments = [f.strip() for f in attachments.split(',')]
+          for file_path in attachments:
+              file_path = os.path.expanduser(file_path)
+              if os.path.exists(file_path):
+                  try:
+                      chunks = load_file_contents(file_path)
+                      loaded_chunks[file_path] = chunks
+                      print(colored(f"Loaded {len(chunks)} chunks from: {file_path}", "green"))
+                  except Exception as e:
+                      print(colored(f"Error loading {file_path}: {e}", "red"))
+
+      # Ensure system message
+      if not messages or messages[0].get("role") != "system":
+          sys_msg = get_system_message(npc) if npc else "You are a helpful assistant."
+          messages.insert(0, {"role": "system", "content": sys_msg})
+
+      # REPL loop
+      while True:
+          try:
+              prompt_str = f"{npc_name}> "
+              user_input = input(prompt_str).strip()
+
+              if not user_input:
+                  continue
+
+              if user_input.lower() == "/sq":
+                  print("Exiting spool mode.")
+                  break
+
+              # Handle /ots for screenshots inline
+              if user_input.startswith("/ots"):
+                  from npcpy.data.image import capture_screenshot
+                  parts = user_input.split()
+                  image_paths = []
+                  if len(parts) > 1:
+                      for p in parts[1:]:
+                          fp = os.path.expanduser(p)
+                          if os.path.exists(fp):
+                              image_paths.append(fp)
+                  else:
+                      ss = capture_screenshot()
+                      if ss and "file_path" in ss:
+                          image_paths.append(ss["file_path"])
+                          print(colored(f"Screenshot: {ss['filename']}", "green"))
+
+                  if image_paths:
+                      vision_prompt = input("Prompt for image(s): ").strip() or "Describe these images."
+                      resp = get_llm_response(
+                          vision_prompt,
+                          model=npc.vision_model if hasattr(npc, 'vision_model') else model,
+                          provider=npc.vision_provider if hasattr(npc, 'vision_provider') else provider,
+                          messages=messages,
+                          images=image_paths,
+                          stream=stream,
+                          npc=npc
+                      )
+                      messages = resp.get('messages', messages)
+                      render_markdown(str(resp.get('response', '')))
+                  continue
+
+              # Add RAG context if files loaded
+              current_prompt = user_input
+              if loaded_chunks:
+                  context_content = ""
+                  for filename, chunks in loaded_chunks.items():
+                      full_text = "\n".join(chunks)
+                      retrieved = rag_search(user_input, full_text, similarity_threshold=0.3)
+                      if retrieved:
+                          context_content += f"\n\nContext from {filename}:\n{retrieved}\n"
+                  if context_content:
+                      current_prompt += f"\n\n--- Relevant context ---{context_content}"
+
+              # Get response
+              resp = get_llm_response(
+                  current_prompt,
+                  model=model,
+                  provider=provider,
+                  messages=messages,
+                  stream=stream,
+                  npc=npc
+              )
+
+              messages = resp.get('messages', messages)
+              response_text = resp.get('response', '')
+
+              # Handle streaming vs non-streaming
+              if hasattr(response_text, '__iter__') and not isinstance(response_text, str):
+                  full_response = ""
+                  for chunk in response_text:
+                      if hasattr(chunk, 'choices') and chunk.choices:
+                          delta = chunk.choices[0].delta
+                          if hasattr(delta, 'content') and delta.content:
+                              print(delta.content, end='', flush=True)
+                              full_response += delta.content
+                  print()
               else:
-                  context['output'] = f"Error: NPC '{npc_name}' not found in team. Available NPCs: {', '.join(current_team.npcs.keys())}"
-                  context['messages'] = output_messages
-                  exit()
-          context['npc'] = current_npc # Ensure the NPC object is updated in context
-          
-          result = enter_spool_mode(**context) # Pass all context as kwargs
-          
-          if isinstance(result, dict):
-              context['output'] = result.get('output', 'Exited Spool Mode.')
-              context['messages'] = result.get('messages', output_messages)
-          else:
-              context['output'] = str(result)
-              context['messages'] = output_messages
-
-      except Exception as e:
-          traceback.print_exc()
-          context['output'] = f"Error entering spool mode: {e}"
-          context['messages'] = output_messages
+                  render_markdown(str(response_text))
+
+              # Track usage if available
+              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 '/sq' to exit or continue.")
+              continue
+          except EOFError:
+              print("\nExiting spool mode.")
+              break
+
+      context['output'] = "Exited spool mode."
+      context['messages'] = messages

npcsh/npc_team/jinxs/modes/wander.jinx

@@ -1,81 +1,186 @@
-jinx_name: "wander"
-description: "Enter wander mode (experimental)"
+jinx_name: wander
+description: Experimental wandering mode - creative exploration with varied temperatures and random events
 inputs:
-  - problem: "" # The problem to wander about.
-  - environment: "" # Optional environment for wander mode.
-  - low_temp: 0.5 # Low temperature setting for LLM.
-  - high_temp: 1.9 # High temperature setting for LLM.
-  - interruption_likelihood: 1.0 # Likelihood of interruption.
-  - sample_rate: 0.4 # Sample rate.
-  - n_high_temp_streams: 5 # Number of high temperature streams.
-  - include_events: False # Whether to include events.
-  - num_events: 3 # Number of events to include.
+  - problem: null
+  - environment: null
+  - low_temp: 0.5
+  - high_temp: 1.9
+  - interruption_likelihood: 1.0
+  - sample_rate: 0.4
+  - n_streams: 5
+  - include_events: false
+  - num_events: 3
+  - model: null
+  - provider: null
+
 steps:
-  - name: "enter_wander"
-    engine: "python"
+  - name: wander_explore
+    engine: python
     code: |
-      import traceback
-      from npcsh.wander import enter_wander_mode
-      
+      import os
+      import random
+      from termcolor import colored
+
+      from npcpy.llm_funcs import get_llm_response
+
+      npc = context.get('npc')
+      messages = context.get('messages', [])
+
       problem = context.get('problem')
       environment = context.get('environment')
-      low_temp = float(context.get('low_temp', 0.5)) # Ensure float type
-      high_temp = float(context.get('high_temp', 1.9)) # Ensure float type
-      interruption_likelihood = float(context.get('interruption_likelihood', 1.0)) # Ensure float type
-      sample_rate = float(context.get('sample_rate', 0.4)) # Ensure float type
-      n_high_temp_streams = int(context.get('n_high_temp_streams', 5)) # Ensure int type
-      include_events = context.get('include_events', False) # Boolean type
-      num_events = int(context.get('num_events', 3)) # Ensure int type
-      
-      current_npc = context.get('npc')
-      llm_model = context.get('model')
-      llm_provider = context.get('provider')
-      output_messages = context.get('messages', [])
-
-      if not problem or not problem.strip():
-          context['output'] = "Usage: /wander <problem> [key=value...]"
-          context['messages'] = output_messages
+      low_temp = float(context.get('low_temp', 0.5))
+      high_temp = float(context.get('high_temp', 1.9))
+      interruption_likelihood = float(context.get('interruption_likelihood', 1.0))
+      sample_rate = float(context.get('sample_rate', 0.4))
+      n_streams = int(context.get('n_streams', 5))
+      include_events = context.get('include_events', False)
+      num_events = int(context.get('num_events', 3))
+
+      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 problem:
+          context['output'] = """Usage: /wander <problem to explore>
+
+      Options:
+        --environment DESC   Metaphorical environment for wandering
+        --low-temp F        Low temperature (default: 0.5)
+        --high-temp F       High temperature (default: 1.9)
+        --n-streams N       Number of exploration streams (default: 5)
+        --include-events    Add random events during wandering
+
+      Example: /wander How might we reimagine urban transportation?"""
+          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)
-      if not llm_model: llm_model = "gemini-1.5-pro" # Example default
-      if not llm_provider: llm_provider = "gemini" # Example default
-
-      try:
-          mode_args = {
-              'problem': problem,
-              'npc': current_npc,
-              'model': llm_model,
-              'provider': llm_provider,
-              'environment': environment,
-              'low_temp': low_temp,
-              'high_temp': high_temp,
-              'interruption_likelihood': interruption_likelihood,
-              'sample_rate': sample_rate,
-              'n_high_temp_streams': n_high_temp_streams,
-              'include_events': include_events,
-              'num_events': num_events
-          }
-          
-          result = enter_wander_mode(**mode_args)
-          
-          output_result = ""
-          if isinstance(result, list) and result:
-              output_result = result[-1].get("insight", "Wander mode session complete.")
+
+      print(f"""
+      ██╗    ██╗ █████╗ ███╗   ██╗██████╗ ███████╗██████╗
+      ██║    ██║██╔══██╗████╗  ██║██╔══██╗██╔════╝██╔══██╗
+      ██║ █╗ ██║███████║██╔██╗ ██║██║  ██║█████╗  ██████╔╝
+      ██║███╗██║██╔══██║██║╚██╗██║██║  ██║██╔══╝  ██╔══██╗
+      ╚███╔███╔╝██║  ██║██║ ╚████║██████╔╝███████╗██║  ██║
+       ╚══╝╚══╝ ╚═╝  ╚═╝╚═╝  ╚═══╝╚═════╝ ╚══════╝╚═╝  ╚═╝
+
+      Experimental Wandering Mode
+      Problem: {problem}
+      Temperature range: {low_temp} - {high_temp}
+      Streams: {n_streams}
+      """)
+
+      # Generate environment if not provided
+      if not environment:
+          env_prompt = f"""Create a rich, metaphorical environment for wandering through while thinking about:
+          "{problem}"
+
+          The environment should:
+          1. Have distinct regions or areas
+          2. Include various elements and features
+          3. Be metaphorically related to the problem
+          4. Be described in 3-5 sentences
+
+          Provide only the description, no framing."""
+
+          print(colored("Generating wandering environment...", "cyan"))
+          resp = get_llm_response(env_prompt, model=model, provider=provider, temperature=0.7, npc=npc)
+          environment = str(resp.get('response', 'A vast conceptual landscape stretches before you.'))
+          print(f"\n{environment}\n")
+
+      # Event types for random encounters
+      event_types = ["encounter", "discovery", "obstacle", "insight", "shift", "memory"]
+
+      all_insights = []
+      wandering_log = []
+
+      for stream_idx in range(n_streams):
+          # Alternate between low and high temperature
+          if stream_idx % 2 == 0:
+              temp = low_temp
+              mode = "focused"
           else:
-              output_result = str(result) if result else "Wander mode session complete."
-              
-          output_messages.append({"role": "assistant", "content": output_result})
-          context['output'] = output_result
-          context['messages'] = output_messages
-          
-      except Exception as e:
-          traceback.print_exc()
-          context['output'] = f"Error during wander mode: {e}"
-          context['messages'] = output_messages
+              temp = high_temp
+              mode = "creative"
+
+          print(colored(f"\n--- Stream {stream_idx + 1}/{n_streams} ({mode}, temp={temp}) ---", "cyan"))
+
+          # Generate random event if enabled
+          event_context = ""
+          if include_events and random.random() < sample_rate:
+              event_type = random.choice(event_types)
+              event_prompt = f"""In the environment: {environment}
+
+              While exploring the problem "{problem}", generate a {event_type} event.
+              The event should be metaphorical and relate to the problem.
+              Describe it in 2-3 sentences."""
+
+              event_resp = get_llm_response(event_prompt, model=model, provider=provider, temperature=0.9, npc=npc)
+              event = str(event_resp.get('response', ''))
+              event_context = f"\n\nEvent ({event_type}): {event}"
+              print(colored(f"[{event_type.upper()}] {event[:100]}...", "yellow"))
+
+          # Main wandering exploration
+          wander_prompt = f"""You are wandering through: {environment}
+
+          Problem being explored: "{problem}"
+          {event_context}
+
+          Previous insights: {all_insights[-3:] if all_insights else 'Starting fresh'}
+
+          In this {mode} exploration (temperature {temp}):
+          1. Let your mind wander through the conceptual space
+          2. Make unexpected connections
+          3. Notice what emerges from the wandering
+          4. Share any insights, questions, or realizations
+
+          Think freely and explore."""
+
+          resp = get_llm_response(wander_prompt, model=model, provider=provider, temperature=temp, npc=npc)
+          stream_output = str(resp.get('response', ''))
+          print(stream_output)
+
+          all_insights.append(stream_output)
+          wandering_log.append({
+              "stream": stream_idx + 1,
+              "mode": mode,
+              "temperature": temp,
+              "event": event_context if include_events else None,
+              "insight": stream_output
+          })
+
+          # Random interruption
+          if random.random() < interruption_likelihood * 0.2:
+              print(colored("\n[Pause for reflection...]", "magenta"))
+              reflect_prompt = f"Briefly reflect on what's emerged so far about: {problem}"
+              reflect_resp = get_llm_response(reflect_prompt, model=model, provider=provider, temperature=0.4, npc=npc)
+              print(colored(str(reflect_resp.get('response', ''))[:200], "magenta"))
+
+      # Synthesis
+      print(colored("\n--- Synthesizing Wanderings ---", "cyan"))
+
+      synthesis_prompt = f"""After wandering through "{environment}" exploring "{problem}":
+
+      All insights gathered:
+      {chr(10).join(all_insights)}
+
+      Synthesize what emerged from this wandering:
+      1. Key themes that appeared
+      2. Unexpected connections made
+      3. New questions raised
+      4. Potential directions to explore further"""
+
+      resp = get_llm_response(synthesis_prompt, model=model, provider=provider, temperature=0.5, npc=npc)
+      synthesis = str(resp.get('response', ''))
+
+      print("\n" + "="*50)
+      print(colored("WANDERING SYNTHESIS", "green", attrs=['bold']))
+      print("="*50)
+      print(synthesis)
+
+      context['output'] = synthesis
+      context['messages'] = messages
+      context['wander_result'] = {
+          'problem': problem,
+          'environment': environment,
+          'log': wandering_log,
+          'insights': all_insights,
+          'synthesis': synthesis
+      }