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

npcsh/npc_team/jinxs/modes/wander.jinx

@@ -0,0 +1,186 @@
+jinx_name: wander
+description: Experimental wandering mode - creative exploration with varied temperatures and random events
+inputs:
+  - 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: wander_explore
+    engine: python
+    code: |
+      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))
+      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()
+
+      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:
+              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
+      }

npcsh/npc_team/jinxs/modes/yap.jinx

@@ -0,0 +1,262 @@
+jinx_name: yap
+description: Voice chat mode - speech-to-text input, text-to-speech output
+inputs:
+  - model: null
+  - provider: null
+  - tts_model: kokoro
+  - voice: af_heart
+  - files: null
+
+steps:
+  - name: yap_repl
+    engine: python
+    code: |
+      import os
+      import sys
+      import time
+      import tempfile
+      import threading
+      import queue
+      from termcolor import colored
+
+      # Audio imports with graceful fallback
+      try:
+          import torch
+          import pyaudio
+          import wave
+          import numpy as np
+          from faster_whisper import WhisperModel
+          from gtts import gTTS
+          from npcpy.data.audio import (
+              FORMAT, CHANNELS, RATE, CHUNK,
+              transcribe_recording, convert_mp3_to_wav, cleanup_temp_files
+          )
+          AUDIO_AVAILABLE = True
+      except ImportError as e:
+          AUDIO_AVAILABLE = False
+          print(colored(f"Audio dependencies not available: {e}", "yellow"))
+          print("Install with: pip install npcsh[audio]")
+
+      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')
+      tts_model = context.get('tts_model', 'kokoro')
+      voice = context.get('voice', 'af_heart')
+
+      model = context.get('model') or (npc.model if npc else None)
+      provider = context.get('provider') or (npc.provider if npc else None)
+
+      print("""
+      ██╗   ██╗ █████╗ ██████╗
+      ╚██╗ ██╔╝██╔══██╗██╔══██╗
+       ╚████╔╝ ███████║██████╔╝
+        ╚██╔╝  ██╔══██║██╔═══╝
+         ██║   ██║  ██║██║
+         ╚═╝   ╚═╝  ╚═╝╚═╝
+
+      Voice Chat Mode
+      """)
+
+      npc_name = npc.name if npc else "yap"
+      print(f"Entering yap mode (NPC: {npc_name}). Type '/yq' to exit.")
+
+      if not AUDIO_AVAILABLE:
+          print(colored("Audio not available. Falling back to text mode.", "yellow"))
+
+      # Load files for RAG context
+      loaded_chunks = {}
+      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_chunks[file_path] = chunks
+                      print(colored(f"Loaded: {file_path}", "green"))
+                  except Exception as e:
+                      print(colored(f"Error loading {file_path}: {e}", "red"))
+
+      # System message for concise voice responses
+      sys_msg = get_system_message(npc) if npc else "You are a helpful assistant."
+      sys_msg += "\n\nProvide brief responses of 1-2 sentences unless asked for more detail. Keep responses clear and conversational for voice."
+
+      if not messages or messages[0].get("role") != "system":
+          messages.insert(0, {"role": "system", "content": sys_msg})
+
+      # Audio state
+      vad_model = None
+      whisper_model = None
+
+      if AUDIO_AVAILABLE:
+          try:
+              # Load VAD model for voice activity detection
+              vad_model, _ = torch.hub.load(
+                  repo_or_dir="snakers4/silero-vad",
+                  model="silero_vad",
+                  force_reload=False,
+                  onnx=False,
+                  verbose=False
+              )
+              vad_model.to('cpu')
+              print(colored("VAD model loaded.", "green"))
+
+              # Load Whisper for STT
+              whisper_model = WhisperModel("base", device="cpu", compute_type="int8")
+              print(colored("Whisper model loaded.", "green"))
+          except Exception as e:
+              print(colored(f"Error loading audio models: {e}", "red"))
+              AUDIO_AVAILABLE = False
+
+      def speak_text(text, tts_model='kokoro', voice='af_heart'):
+          """Convert text to speech and play it"""
+          if not AUDIO_AVAILABLE:
+              return
+
+          try:
+              # Use gTTS as fallback
+              tts = gTTS(text=text, lang='en')
+              with tempfile.NamedTemporaryFile(suffix='.mp3', delete=False) as f:
+                  tts.save(f.name)
+                  wav_path = convert_mp3_to_wav(f.name)
+
+              # Play audio
+              import subprocess
+              if sys.platform == 'darwin':
+                  subprocess.run(['afplay', wav_path], check=True)
+              elif sys.platform == 'linux':
+                  subprocess.run(['aplay', wav_path], check=True)
+              else:
+                  # Windows
+                  import winsound
+                  winsound.PlaySound(wav_path, winsound.SND_FILENAME)
+
+              cleanup_temp_files([f.name, wav_path])
+          except Exception as e:
+              print(colored(f"TTS error: {e}", "red"))
+
+      def record_audio(duration=5):
+          """Record audio from microphone"""
+          if not AUDIO_AVAILABLE:
+              return None
+
+          try:
+              p = pyaudio.PyAudio()
+              stream = p.open(format=FORMAT, channels=CHANNELS, rate=RATE, input=True, frames_per_buffer=CHUNK)
+
+              print(colored("Recording...", "cyan"), end='', flush=True)
+              frames = []
+              for _ in range(0, int(RATE / CHUNK * duration)):
+                  data = stream.read(CHUNK)
+                  frames.append(data)
+              print(colored(" Done.", "cyan"))
+
+              stream.stop_stream()
+              stream.close()
+              p.terminate()
+
+              # Save to temp file
+              with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as f:
+                  wf = wave.open(f.name, 'wb')
+                  wf.setnchannels(CHANNELS)
+                  wf.setsampwidth(p.get_sample_size(FORMAT))
+                  wf.setframerate(RATE)
+                  wf.writeframes(b''.join(frames))
+                  wf.close()
+                  return f.name
+          except Exception as e:
+              print(colored(f"Recording error: {e}", "red"))
+              return None
+
+      def transcribe_audio(audio_path):
+          """Transcribe audio to text using Whisper"""
+          if not whisper_model or not audio_path:
+              return ""
+
+          try:
+              segments, _ = whisper_model.transcribe(audio_path, beam_size=5)
+              text = " ".join([seg.text for seg in segments])
+              cleanup_temp_files([audio_path])
+              return text.strip()
+          except Exception as e:
+              print(colored(f"Transcription error: {e}", "red"))
+              return ""
+
+      # REPL loop
+      while True:
+          try:
+              # Voice input or text input
+              if AUDIO_AVAILABLE:
+                  prompt_str = f"{npc_name}:yap> [Press Enter to speak, or type] "
+              else:
+                  prompt_str = f"{npc_name}:yap> "
+
+              user_input = input(prompt_str).strip()
+
+              if user_input.lower() == "/yq":
+                  print("Exiting yap mode.")
+                  break
+
+              # Empty input = record audio
+              if not user_input and AUDIO_AVAILABLE:
+                  audio_path = record_audio(5)
+                  if audio_path:
+                      user_input = transcribe_audio(audio_path)
+                      if user_input:
+                          print(colored(f"You said: {user_input}", "cyan"))
+                      else:
+                          print(colored("Could not transcribe audio.", "yellow"))
+                          continue
+                  else:
+                      continue
+
+              if not user_input:
+                  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{retrieved}\n"
+                  if context_content:
+                      current_prompt += f"\n\nContext:{context_content}"
+
+              # Get response
+              resp = get_llm_response(
+                  current_prompt,
+                  model=model,
+                  provider=provider,
+                  messages=messages,
+                  stream=False,  # Don't stream for voice
+                  npc=npc
+              )
+
+              messages = resp.get('messages', messages)
+              response_text = str(resp.get('response', ''))
+
+              # Display and speak response
+              print(colored(f"{npc_name}: ", "green") + response_text)
+
+              if AUDIO_AVAILABLE:
+                  speak_text(response_text, tts_model, voice)
+
+          except KeyboardInterrupt:
+              print("\nUse '/yq' to exit or continue.")
+              continue
+          except EOFError:
+              print("\nExiting yap mode.")
+              break
+
+      context['output'] = "Exited yap mode."
+      context['messages'] = messages

npcsh/npc_team/jinxs/npc_studio/npc-studio.jinx

@@ -0,0 +1,77 @@
+jinx_name: "npc-studio"
+description: "Start npc studio"
+inputs:
+  - user_command: ""
+steps:
+  - name: "launch_npc_studio"
+    engine: "python"
+    code: |
+      import os
+      import subprocess
+      import sys
+      from pathlib import Path
+      import traceback
+      
+      NPC_STUDIO_DIR = Path.home() / ".npcsh" / "npc-studio"
+      
+      user_command = context.get('user_command')
+      output_messages = context.get('messages', [])
+      output_result = ""
+      
+      try:
+          if not NPC_STUDIO_DIR.exists():
+              os.makedirs(NPC_STUDIO_DIR.parent, exist_ok=True)
+              subprocess.check_call([
+                  "git", "clone",
+                  "https://github.com/npc-worldwide/npc-studio.git",
+                  str(NPC_STUDIO_DIR)
+              ])
+          else:
+              subprocess.check_call(
+                  ["git", "pull"],
+                  cwd=NPC_STUDIO_DIR
+              )
+          
+          subprocess.check_call(
+              ["npm", "install"], 
+              cwd=NPC_STUDIO_DIR
+          )
+          
+          req_file = NPC_STUDIO_DIR / "requirements.txt"
+          if req_file.exists():
+              subprocess.check_call([
+                  sys.executable, 
+                  "-m", 
+                  "pip", 
+                  "install", 
+                  "-r", 
+                  str(req_file)
+              ])
+          
+          backend = subprocess.Popen(
+              [sys.executable, "npc_studio_serve.py"],
+              cwd=NPC_STUDIO_DIR
+          )
+          
+          dev_server = subprocess.Popen(
+              ["npm", "run", "dev"],
+              cwd=NPC_STUDIO_DIR
+          )
+          
+          frontend = subprocess.Popen(
+              ["npm", "start"],
+              cwd=NPC_STUDIO_DIR
+          )
+          
+          output_result = (
+              f"NPC Studio started!\n"
+              f"Backend PID={backend.pid}, "
+              f"Dev Server PID={dev_server.pid}, "
+              f"Frontend PID={frontend.pid}"
+          )
+      except Exception as e:
+          traceback.print_exc()
+          output_result = f"Failed to start NPC Studio: {e}"
+      
+      context['output'] = output_result
+      context['messages'] = output_messages

npcsh/npc_team/jinxs/utils/agent.jinx

@@ -0,0 +1,17 @@
+jinx_name: agent
+description: Provides an LLM response with tool use enabled.
+inputs:
+  - query
+  - auto_process_tool_calls: True
+  - use_core_tools: True
+steps:
+  - name: get_agent_response
+    engine: python
+    code: |
+      response = npc.get_llm_response(
+          request=query,
+          messages=context.get('messages', []),
+          auto_process_tool_calls={{ auto_process_tool_calls | default(True) }},
+          use_core_tools={{ use_core_tools | default(True) }}
+      )
+      output = response.get('response', '')

npcsh/npc_team/jinxs/utils/chat.jinx

@@ -0,0 +1,44 @@
+jinx_name: chat
+description: Simple chat mode - LLM conversation without tool execution
+inputs:
+  - query: null
+  - model: null
+  - provider: null
+  - stream: true
+
+steps:
+  - name: chat_response
+    engine: python
+    code: |
+      from npcpy.llm_funcs import get_llm_response
+
+      npc = context.get('npc')
+      messages = context.get('messages', [])
+      query = context.get('query', '')
+      stream = context.get('stream', True)
+
+      model = context.get('model') or (npc.model if npc else None)
+      provider = context.get('provider') or (npc.provider if npc else None)
+
+      if not query:
+          context['output'] = ''
+          context['messages'] = messages
+      else:
+          response = get_llm_response(
+              query,
+              model=model,
+              provider=provider,
+              npc=npc,
+              stream=stream,
+              messages=messages
+          )
+
+          context['output'] = response.get('response', '')
+          context['messages'] = response.get('messages', messages)
+
+          # Track usage
+          if 'usage' in response and npc and hasattr(npc, 'shared_context'):
+              usage = response['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

npcsh/npc_team/jinxs/utils/cmd.jinx

@@ -0,0 +1,44 @@
+jinx_name: cmd
+description: Command mode - LLM generates and executes shell commands
+inputs:
+  - query: null
+  - model: null
+  - provider: null
+  - stream: true
+
+steps:
+  - name: cmd_execute
+    engine: python
+    code: |
+      from npcpy.llm_funcs import execute_llm_command
+
+      npc = context.get('npc')
+      messages = context.get('messages', [])
+      query = context.get('query', '')
+      stream = context.get('stream', True)
+
+      model = context.get('model') or (npc.model if npc else None)
+      provider = context.get('provider') or (npc.provider if npc else None)
+
+      if not query:
+          context['output'] = ''
+          context['messages'] = messages
+      else:
+          response = execute_llm_command(
+              query,
+              model=model,
+              provider=provider,
+              npc=npc,
+              stream=stream,
+              messages=messages
+          )
+
+          context['output'] = response.get('response', '')
+          context['messages'] = response.get('messages', messages)
+
+          # Track usage
+          if 'usage' in response and npc and hasattr(npc, 'shared_context'):
+              usage = response['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