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

npcsh/npc_team/jinxs/modes/yap.jinx

@@ -1,25 +1,262 @@
-jinx_name: "yap"
-description: "Enter voice chat (yap) mode"
-inputs: [] # Yap mode takes its parameters directly from the environment/kwargs
+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: "enter_yap"
-    engine: "python"
+  - name: yap_repl
+    engine: python
     code: |
-      import traceback
-      from npcsh.yap import enter_yap_mode
-      
-      output_messages = context.get('messages', [])
+      import os
+      import sys
+      import time
+      import tempfile
+      import threading
+      import queue
+      from termcolor import colored
 
+      # Audio imports with graceful fallback
       try:
-          result = enter_yap_mode(**context) # Pass all context as kwargs
-          
-          if isinstance(result, dict):
-              context['output'] = result.get('output', 'Exited Yap 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 yap mode: {e}"
-          context['messages'] = output_messages
+          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/utils/chat.jinx

@@ -1,17 +1,44 @@
 jinx_name: chat
-description: Provides a direct LLM response without tool use.
+description: Simple chat mode - LLM conversation without tool execution
 inputs:
-  - query
-  - auto_process_tool_calls: False
-  - use_core_tools: False
+  - query: null
+  - model: null
+  - provider: null
+  - stream: true
+
 steps:
-  - name: get_chat_response
+  - name: chat_response
     engine: python
     code: |
-      response = npc.get_llm_response(
-          request=query,
-          messages=context.get('messages', []),
-          auto_process_tool_calls={{ auto_process_tool_calls | default(False) }},
-          use_core_tools={{ use_core_tools | default(False) }}
-      )
-      output = response.get('response', '')
+      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

npcsh/npc_team/jinxs/utils/search.jinx

@@ -41,11 +41,11 @@ steps:
           
           current_npc = current_state.npc
           current_team = current_state.team
-          
+
           npc_name = getattr(current_npc, 'name', '__none__') if current_npc else '__none__'
           team_name = getattr(current_team, 'name', '__none__') if current_team else '__none__'
           current_path = os.getcwd()
-          db_path = os.path.expanduser(context.get("history_db_path"))
+          db_path = os.path.expanduser(context.get("history_db_path") or "~/.npcsh/npcsh_history.db")
           
           try:
               cmd_history = CommandHistory(db_path)
@@ -101,7 +101,7 @@ steps:
 
                   result = execute_rag_command(
                       command=query,
-                      vector_db_path=os.path.expanduser(context.get('vector_db_path')),
+                      vector_db_path=os.path.expanduser(context.get('vector_db_path') or "~/.npcsh/npcsh_chroma.db"),
                       embedding_model=emodel,
                       embedding_provider=eprovider,
                       file_contents=file_contents or None

npcsh/npc_team/jinxs/utils/usage.jinx

@@ -0,0 +1,33 @@
+jinx_name: usage
+description: Display current session token usage and cost
+inputs: []
+steps:
+  - name: show_usage
+    engine: python
+    code: |
+      state = context.get('state')
+      if not state:
+          output = "No state available"
+      else:
+          inp = getattr(state, 'session_input_tokens', 0)
+          out = getattr(state, 'session_output_tokens', 0)
+          cost = getattr(state, 'session_cost_usd', 0.0)
+          turns = getattr(state, 'turn_count', 0)
+          total = inp + out
+
+          def fmt(n):
+              return f"{n/1000:.1f}k" if n >= 1000 else str(n)
+
+          def fmt_cost(c):
+              if c == 0:
+                  return "free (local)"
+              elif c < 0.01:
+                  return f"${c:.4f}"
+              else:
+                  return f"${c:.2f}"
+
+          output = f"Session Usage\n"
+          output += f"Tokens: {fmt(inp)} in / {fmt(out)} out ({fmt(total)} total)\n"
+          output += f"Cost:   {fmt_cost(cost)}\n"
+          output += f"Turns:  {turns}"
+      context['output'] = output

npcsh/npcsh.py

@@ -32,16 +32,43 @@ except importlib.metadata.PackageNotFoundError:
     VERSION = "unknown"
 
 from npcsh._state import (
-    initial_state, 
+    initial_state,
     orange,
     ShellState,
-    execute_command, 
+    execute_command,
     make_completer,
     process_result,
     readline_safe_prompt,
-    setup_shell, 
+    setup_shell,
     get_multiline_input,
-    )
+)
+
+
+def display_usage(state: ShellState):
+    """Display token usage and cost summary."""
+    inp = state.session_input_tokens
+    out = state.session_output_tokens
+    cost = state.session_cost_usd
+    turns = state.turn_count
+    total = inp + out
+
+    def fmt(n):
+        return f"{n/1000:.1f}k" if n >= 1000 else str(n)
+
+    def fmt_cost(c):
+        if c == 0:
+            return "free"
+        elif c < 0.01:
+            return f"${c:.4f}"
+        else:
+            return f"${c:.2f}"
+
+    print(colored("\n─────────────────────────────", "cyan"))
+    print(colored("📊 Session Usage", "cyan", attrs=["bold"]))
+    print(f"   Tokens: {fmt(inp)} in / {fmt(out)} out ({fmt(total)} total)")
+    print(f"   Cost:   {fmt_cost(cost)}")
+    print(f"   Turns:  {turns}")
+    print(colored("─────────────────────────────\n", "cyan"))
 
 
 def print_welcome_message():
@@ -143,10 +170,13 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState, router)
         try:
             if state.messages is not None:
                 if len(state.messages) > 20:
+                    # Display usage before compacting
+                    display_usage(state)
+
                     planning_state = {
-                        "goal": "ongoing npcsh session", 
-                        "facts": [f"Working in {state.current_path}", f"Current mode: {state.current_mode}"], 
-                        "successes": [], 
+                        "goal": "ongoing npcsh session",
+                        "facts": [f"Working in {state.current_path}", f"Current mode: {state.current_mode}"],
+                        "successes": [],
                         "mistakes": [],
                         "todos": [],
                         "constraints": ["Follow user requests", "Use appropriate mode for tasks"]
@@ -164,22 +194,48 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState, router)
             if isinstance(state.npc, NPC) and state.npc.model:
                 display_model = state.npc.model
 
+            npc_name = state.npc.name if isinstance(state.npc, NPC) else "npcsh"
+            team_name = state.team.name if state.team else ""
+
+            # Check if model is local (ollama) or remote (has cost)
+            provider = state.chat_provider
+            if isinstance(state.npc, NPC) and state.npc.provider:
+                provider = state.npc.provider
+            is_local = provider and provider.lower() in ['ollama', 'transformers', 'local']
+
+            # Build token/cost string for hint line
+            if state.session_input_tokens > 0 or state.session_output_tokens > 0:
+                usage_str = f"📊 {state.session_input_tokens:,} in / {state.session_output_tokens:,} out"
+                if not is_local and state.session_cost_usd > 0:
+                    usage_str += f" | ${state.session_cost_usd:.4f}"
+                token_hint = colored(usage_str, "white", attrs=["dark"])
+            else:
+                token_hint = ""
+
             if is_windows:
-                cwd_part = os.path.basename(state.current_path)
-                if isinstance(state.npc, NPC):
-                    prompt_end = f":{state.npc.name}:{display_model}> "
-                else:
-                    prompt_end = ":npcsh> "
-                prompt = f"{cwd_part}{prompt_end}"
+                print(f"cwd: {state.current_path}")
+                status = f"{npc_name}"
+                if team_name:
+                    status += f" | {team_name}"
+                status += f" | {display_model}"
+                print(status)
+                prompt = "> "
             else:
-                cwd_colored = colored(os.path.basename(state.current_path), "blue")
-                if isinstance(state.npc, NPC):
-                    prompt_end = f":🤖{orange(state.npc.name)}:{display_model}> "
-                else:
-                    prompt_end = f":🤖{colored('npc', 'blue', attrs=['bold'])}{colored('sh', 'yellow')}> "
-                prompt = readline_safe_prompt(f"{cwd_colored}{prompt_end}")
+                # Line 1: cwd (full path)
+                cwd_line = colored("📁 ", "blue") + colored(state.current_path, "blue")
+                print(cwd_line)
+
+                # Line 2: npc | team | model
+                npc_colored = orange(npc_name) if isinstance(state.npc, NPC) else colored("npcsh", "cyan")
+                parts = [colored("🤖 ", "yellow") + npc_colored]
+                if team_name:
+                    parts.append(colored("👥 ", "magenta") + colored(team_name, "magenta"))
+                parts.append(colored(display_model, "white", attrs=["dark"]))
+                print(" | ".join(parts))
+
+                prompt = colored("> ", "green")
 
-            user_input = get_multiline_input(prompt).strip()
+            user_input = get_multiline_input(prompt, state=state, router=router, token_hint=token_hint).strip()
           
             if user_input == "\x1a":
                 exit_shell(state)