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

npcsh/npc_team/jinxs/lib/computer_use/type_text.jinx

@@ -0,0 +1,27 @@
+jinx_name: type_text
+description: Type text using keyboard
+inputs:
+  - text: ""  # Text to type
+
+steps:
+  - name: perform_type
+    engine: python
+    code: |
+      from npcpy.work.desktop import perform_action
+
+      text = context.get('text', '')
+      messages = context.get('messages', [])
+
+      if not text:
+          context['output'] = "Usage: /type_text <text to type>"
+          context['messages'] = messages
+          exit()
+
+      try:
+          perform_action({'type': 'type', 'text': text})
+          preview = text[:30] + "..." if len(text) > 30 else text
+          context['output'] = f"Typed: {preview}"
+      except Exception as e:
+          context['output'] = f"Type failed: {e}"
+
+      context['messages'] = messages

npcsh/npc_team/jinxs/lib/computer_use/wait.jinx

@@ -0,0 +1,21 @@
+jinx_name: wait
+description: Wait/pause for a specified duration in seconds
+inputs:
+  - duration: 1  # Duration to wait in seconds
+
+steps:
+  - name: perform_wait
+    engine: python
+    code: |
+      import time
+
+      duration = float(context.get('duration', 1))
+      messages = context.get('messages', [])
+
+      try:
+          time.sleep(duration)
+          context['output'] = f"Waited {duration} seconds"
+      except Exception as e:
+          context['output'] = f"Wait failed: {e}"
+
+      context['messages'] = messages

{npcsh-1.1.14.data/data/npcsh/npc_team → npcsh/npc_team/jinxs/lib/core}/edit_file.jinx

@@ -13,9 +13,9 @@ steps:
       from npcpy.llm_funcs import get_llm_response
       
     
-      file_path = os.path.expanduser("{{ file_path }}")
-      edit_instructions = "{{ edit_instructions }}"
-      backup_str = "{{ backup }}"
+      file_path = os.path.expanduser({{ file_path | tojson }})
+      edit_instructions = {{ edit_instructions | string | tojson }}
+      backup_str = {{ backup | default("true") | string | tojson }}
       create_backup = backup_str.lower() not in ('false', 'no', '0', '')
       
     

{npcsh-1.1.14.data/data/npcsh/npc_team → npcsh/npc_team/jinxs/lib/core}/load_file.jinx

@@ -10,7 +10,7 @@ steps:
       from npcpy.data.load import load_file_contents
       
       # Expand user path and get absolute path
-      file_path = os.path.expanduser("{{ file_path }}")
+      file_path = os.path.expanduser({{ file_path | tojson }})
       
       # Check if file exists
       if not os.path.exists(file_path):

npcsh/npc_team/jinxs/lib/core/paste.jinx

@@ -0,0 +1,134 @@
+jinx_name: paste
+description: Grabs content from clipboard (images or text) and saves/displays it. Use this when Ctrl+V paste doesn't work properly.
+inputs:
+- output_path:
+    default: ""
+    description: "Optional path to save image to. If empty, saves to temp file."
+steps:
+  - name: "paste_clipboard"
+    engine: "python"
+    code: |
+      import tempfile
+      import os
+      from datetime import datetime
+      import io
+
+      output_path = ({{ output_path | default("") | tojson }} or "").strip()
+      image_saved = False
+      text_content = None
+
+      # Try PIL/Pillow with ImageGrab first (works on most systems)
+      try:
+          from PIL import ImageGrab, Image
+
+          # Try to grab image from clipboard
+          img = ImageGrab.grabclipboard()
+
+          if img is not None:
+              if isinstance(img, Image.Image):
+                  # It's an image
+                  if output_path:
+                      save_path = os.path.expanduser(output_path)
+                  else:
+                      timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+                      fd, save_path = tempfile.mkstemp(suffix='.png', prefix=f'npcsh_paste_{timestamp}_')
+                      os.close(fd)
+
+                  img.save(save_path, 'PNG')
+                  file_size = os.path.getsize(save_path)
+
+                  if file_size > 1024 * 1024:
+                      size_str = f"{file_size / (1024*1024):.1f} MB"
+                  elif file_size > 1024:
+                      size_str = f"{file_size / 1024:.1f} KB"
+                  else:
+                      size_str = f"{file_size} bytes"
+
+                  output = f"Image saved to: {save_path} ({size_str}, {img.size[0]}x{img.size[1]})"
+                  context['pasted_image_path'] = save_path
+                  image_saved = True
+
+              elif isinstance(img, list):
+                  # It's a list of file paths (copied files)
+                  output = f"Clipboard contains {len(img)} file(s):\n" + "\n".join(img)
+                  context['pasted_files'] = img
+                  image_saved = True
+
+      except ImportError:
+          pass
+      except Exception as e:
+          # ImageGrab failed, try other methods
+          pass
+
+      # If no image, try to get text via tkinter
+      if not image_saved:
+          try:
+              import tkinter as tk
+
+              root = tk.Tk()
+              root.withdraw()
+
+              try:
+                  text_content = root.clipboard_get()
+              except tk.TclError:
+                  text_content = None
+
+              root.destroy()
+
+          except Exception as e:
+              pass
+
+      # If still nothing, try GTK
+      if not image_saved and text_content is None:
+          try:
+              import gi
+              gi.require_version('Gtk', '3.0')
+              from gi.repository import Gtk, Gdk, GdkPixbuf
+
+              clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
+
+              # Try image first
+              pixbuf = clipboard.wait_for_image()
+              if pixbuf:
+                  if output_path:
+                      save_path = os.path.expanduser(output_path)
+                  else:
+                      timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+                      fd, save_path = tempfile.mkstemp(suffix='.png', prefix=f'npcsh_paste_{timestamp}_')
+                      os.close(fd)
+
+                  pixbuf.savev(save_path, 'png', [], [])
+                  file_size = os.path.getsize(save_path)
+
+                  if file_size > 1024 * 1024:
+                      size_str = f"{file_size / (1024*1024):.1f} MB"
+                  elif file_size > 1024:
+                      size_str = f"{file_size / 1024:.1f} KB"
+                  else:
+                      size_str = f"{file_size} bytes"
+
+                  output = f"Image saved to: {save_path} ({size_str}, {pixbuf.get_width()}x{pixbuf.get_height()})"
+                  context['pasted_image_path'] = save_path
+                  image_saved = True
+              else:
+                  # Try text
+                  text_content = clipboard.wait_for_text()
+
+          except Exception as e:
+              pass
+
+      # Handle text content
+      if not image_saved and text_content:
+          line_count = text_content.count('\n') + 1
+          char_count = len(text_content)
+          context['pasted_text'] = text_content
+
+          if line_count > 10:
+              preview_lines = text_content.split('\n')[:10]
+              preview = '\n'.join(preview_lines)
+              output = f"Clipboard text ({line_count} lines, {char_count} chars):\n---\n{preview}\n... ({line_count - 10} more lines)\n---"
+          else:
+              output = f"Clipboard text ({line_count} lines, {char_count} chars):\n---\n{text_content}\n---"
+
+      elif not image_saved:
+          output = "Clipboard is empty or could not access clipboard.\nMake sure you have PIL/Pillow installed: pip install Pillow"

{npcsh-1.1.14.data/data/npcsh/npc_team → npcsh/npc_team/jinxs/lib/core}/search.jinx

@@ -25,7 +25,8 @@ steps:
     code: |
       import os
       import traceback
-      
+      from npcpy.data.web import search_web
+
       # Access query from context
       query = context.get('query')
       if not query or not query.strip():

npcsh/npc_team/jinxs/{code → lib/core}/sh.jinx

@@ -1,5 +1,5 @@
 jinx_name: sh
-description: Execute bash queries. Should be used to grep for file contents, list directories, explore information to answer user questions more practically.
+description: Execute bash queries. Should be used to grep for file contents, list directories, explore information to answer user questions more practically. NEVER use ls -R on directories that may contain node_modules, .git, or other large dependency folders - this will exceed token limits. Use targeted ls commands instead.
 inputs:
   - bash_command
 steps:
@@ -9,7 +9,7 @@ steps:
       import subprocess
       import os
 
-      cmd = '{{ bash_command }}'
+      cmd = {{ bash_command | tojson }}
       output = ""
 
       process = subprocess.Popen(
@@ -20,12 +20,6 @@ steps:
       )
       stdout, stderr = process.communicate()
 
-      # 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')}"
       else:

npcsh/npc_team/jinxs/{code → lib/core}/sql.jinx

@@ -8,7 +8,7 @@ steps:
   - engine: python
     code: |
       import pandas as pd
-      query = "{{ sql_query }}"
+      query = {{ sql_query | tojson }}
       try:
         df = pd.read_sql_query(query, npc.db_conn)
       except Exception as e:

npcsh/npc_team/jinxs/lib/orchestration/convene.jinx

@@ -0,0 +1,232 @@
+jinx_name: convene
+description: Run a cycle of discussions between NPCs on a topic. The orchestrator convenes agents to discuss and synthesize.
+inputs:
+  - topic: ""
+  - npcs: "alicanto,corca,guac"
+  - rounds: 3
+  - model: null
+  - provider: null
+steps:
+  - name: convene_discussion
+    engine: python
+    code: |
+      from termcolor import colored
+      from npcpy.llm_funcs import get_llm_response
+
+      topic = context.get('topic', '')
+      npcs_str = context.get('npcs', 'alicanto,corca,guac')
+      rounds = int(context.get('rounds', 3))
+
+      npc = context.get('npc')
+      team = context.get('team')
+      messages = context.get('messages', [])
+
+      model = context.get('model') or (npc.model if npc else 'gemini-1.5-flash')
+      provider = context.get('provider') or (npc.provider if npc else 'gemini')
+
+      if not topic:
+          context['output'] = """Usage: /convene <topic>
+
+      Options:
+        --npcs LIST      Comma-separated NPC names (default: alicanto,corca,guac)
+        --rounds N       Number of discussion rounds (default: 3)
+
+      Example: /convene "How should we approach the database migration?" --npcs corca,guac,frederic
+      """
+          exit()
+
+      npc_names = [n.strip() for n in npcs_str.split(',')]
+
+      print(f"""
+       ██████  ██████  ███    ██ ██    ██ ███████ ███    ██ ███████
+      ██      ██    ██ ████   ██ ██    ██ ██      ████   ██ ██
+      ██      ██    ██ ██ ██  ██ ██    ██ █████   ██ ██  ██ █████
+      ██      ██    ██ ██  ██ ██  ██  ██  ██      ██  ██ ██ ██
+       ██████  ██████  ██   ████   ████   ███████ ██   ████ ███████
+
+      Convening Discussion
+      Topic: {topic}
+      Participants: {', '.join(npc_names)}
+      Rounds: {rounds}
+      """)
+
+      # Get NPC personas
+      participants = []
+      for name in npc_names:
+          if team and hasattr(team, 'npcs') and name in team.npcs:
+              target_npc = team.npcs[name]
+              persona = getattr(target_npc, 'primary_directive', f'{name} specialist')
+              participants.append({'name': name, 'persona': persona, 'npc': target_npc})
+          else:
+              participants.append({'name': name, 'persona': f'{name} - general assistant', 'npc': None})
+
+      import random
+
+      discussion_log = []
+
+      for round_num in range(1, rounds + 1):
+          print(colored(f"\n{'='*60}", "cyan"))
+          print(colored(f"  ROUND {round_num}/{rounds}", "cyan", attrs=["bold"]))
+          print(colored(f"{'='*60}", "cyan"))
+
+          round_contributions = []
+
+          for participant in participants:
+              name = participant['name']
+              persona = participant['persona']
+
+              # Build context from previous contributions
+              prev_context = ""
+              if discussion_log:
+                  prev_context = "\n\nPrevious discussion:\n"
+                  for entry in discussion_log[-len(participants)*2:]:
+                      prev_context += f"[{entry['speaker']}]: {entry['contribution'][:200]}...\n"
+
+              if round_contributions:
+                  prev_context += "\nThis round so far:\n"
+                  for entry in round_contributions:
+                      prev_context += f"[{entry['speaker']}]: {entry['contribution'][:200]}...\n"
+
+              prompt = f"""You are {name}. {persona}
+
+      Topic under discussion: "{topic}"
+      {prev_context}
+
+      Provide your perspective on this topic. Be concise but insightful.
+      Build on what others have said if applicable.
+      If you disagree with something, explain why constructively.
+      """
+
+              print(colored(f"\n[{name}]:", "yellow", attrs=["bold"]))
+
+              resp = get_llm_response(
+                  prompt,
+                  model=model,
+                  provider=provider,
+                  npc=participant.get('npc') or npc,
+                  temperature=0.7
+              )
+
+              contribution = str(resp.get('response', ''))
+              print(contribution)
+
+              entry = {
+                  'round': round_num,
+                  'speaker': name,
+                  'contribution': contribution
+              }
+              round_contributions.append(entry)
+              discussion_log.append(entry)
+
+              # Sample a followup from another participant
+              other_participants = [p for p in participants if p['name'] != name]
+              if other_participants:
+                  followup_participant = random.choice(other_participants)
+                  followup_name = followup_participant['name']
+                  followup_persona = followup_participant['persona']
+
+                  followup_prompt = f"""You are {followup_name}. {followup_persona}
+
+      Topic: "{topic}"
+
+      {name} just said: "{contribution[:500]}"
+
+      Respond briefly to this specific point - agree, disagree, build on it, or ask a clarifying question.
+      Keep it to 2-3 sentences.
+      """
+
+                  print(colored(f"\n  [{followup_name} responds]:", "cyan"))
+
+                  followup_resp = get_llm_response(
+                      followup_prompt,
+                      model=model,
+                      provider=provider,
+                      npc=followup_participant.get('npc') or npc,
+                      temperature=0.7
+                  )
+
+                  followup_contribution = str(followup_resp.get('response', ''))
+                  print(f"  {followup_contribution}")
+
+                  discussion_log.append({
+                      'round': round_num,
+                      'speaker': followup_name,
+                      'contribution': followup_contribution,
+                      'type': 'followup'
+                  })
+
+                  # Probability of original speaker responding back vs someone else
+                  if random.random() < 0.4:
+                      # Original speaker responds
+                      responder = participant
+                      responder_name = name
+                  else:
+                      # Sample from others (could be followup person or someone else)
+                      responder = random.choice(other_participants)
+                      responder_name = responder['name']
+
+                  if random.random() < 0.6:  # 60% chance of a counter-response
+                      counter_prompt = f"""You are {responder_name}. {responder['persona']}
+
+      Topic: "{topic}"
+
+      {followup_name} responded: "{followup_contribution}"
+
+      Brief reaction (1-2 sentences). Move the discussion forward.
+      """
+
+                      print(colored(f"\n  [{responder_name}]:", "magenta"))
+
+                      counter_resp = get_llm_response(
+                          counter_prompt,
+                          model=model,
+                          provider=provider,
+                          npc=responder.get('npc') or npc,
+                          temperature=0.7
+                      )
+
+                      counter_contribution = str(counter_resp.get('response', ''))
+                      print(f"  {counter_contribution}")
+
+                      discussion_log.append({
+                          'round': round_num,
+                          'speaker': responder_name,
+                          'contribution': counter_contribution,
+                          'type': 'counter'
+                      })
+
+      # Synthesis
+      print(colored(f"\n{'='*60}", "green"))
+      print(colored("  SYNTHESIS", "green", attrs=["bold"]))
+      print(colored(f"{'='*60}", "green"))
+
+      all_contributions = "\n".join([
+          f"[{e['speaker']} - Round {e['round']}]: {e['contribution']}"
+          for e in discussion_log
+      ])
+
+      synthesis_prompt = f"""As the convener of this discussion on "{topic}", synthesize the key points:
+
+      Full discussion:
+      {all_contributions}
+
+      Provide:
+      1. Key agreements and consensus points
+      2. Areas of disagreement or tension
+      3. Novel ideas that emerged
+      4. Recommended next steps or actions
+      """
+
+      resp = get_llm_response(synthesis_prompt, model=model, provider=provider, npc=npc, temperature=0.4)
+      synthesis = str(resp.get('response', ''))
+      print(synthesis)
+
+      context['output'] = synthesis
+      context['messages'] = messages
+      context['convene_result'] = {
+          'topic': topic,
+          'participants': npc_names,
+          'rounds': rounds,
+          'discussion': discussion_log,
+          'synthesis': synthesis
+      }

npcsh/npc_team/jinxs/lib/orchestration/delegate.jinx

@@ -0,0 +1,184 @@
+jinx_name: delegate
+description: Delegate a task to another NPC with review and feedback loop until completion. Choose the NPC whose directive best matches the task.
+inputs:
+  - npc_name:
+      description: "Name of the NPC to delegate to"
+  - task:
+      description: "The task or request to delegate to the NPC"
+  - max_iterations: "10"
+steps:
+  - name: delegate_with_review
+    engine: python
+    code: |
+      from termcolor import colored
+      from npcpy.llm_funcs import get_llm_response
+
+      # Try to get spinner for status updates
+      try:
+          from npcsh.ui import get_current_spinner
+          spinner = get_current_spinner()
+      except:
+          spinner = None
+
+      target_name = {{ npc_name | default("") | tojson }}.lower().strip()
+      task_request = {{ task | default("") | tojson }}
+      max_iters = int({{ max_iterations | default("10") | tojson }} or "10")
+
+      team_obj = context.get('team') or getattr(npc, 'team', None)
+      orchestrator = context.get('npc') or npc
+      orchestrator_name = getattr(orchestrator, 'name', 'orchestrator')
+
+      if not team_obj:
+          output = "Error: No team available for delegation"
+          exit()
+
+      if not hasattr(team_obj, 'npcs') or target_name not in team_obj.npcs:
+          available = list(team_obj.npcs.keys()) if hasattr(team_obj, 'npcs') else []
+          output = "Error: NPC '{}' not found. Available: {}".format(target_name, ', '.join(available))
+          exit()
+
+      target_npc = team_obj.npcs[target_name]
+      target_jinxs = dict((k, v) for k, v in target_npc.jinxs_dict.items() if k != 'delegate')
+
+      sep = '-' * 60
+      print(colored("\n" + sep, "cyan"))
+      print(colored("  Delegating to @" + target_name, "yellow", attrs=["bold"]))
+      task_preview = task_request[:100] + ('...' if len(task_request) > 100 else '')
+      print(colored("  Task: " + task_preview, "white", attrs=["dark"]))
+      print(colored(sep + "\n", "cyan"))
+      print(colored("  [{}] Model: {}".format(target_name, target_npc.model), "white", attrs=["dark"]))
+      jinx_list = ', '.join(list(target_jinxs.keys())[:8])
+      print(colored("  [{}] Jinxs: {}...".format(target_name, jinx_list), "white", attrs=["dark"]))
+
+      # Update spinner to show sub-agent
+      if spinner:
+          spinner.set_message("{} delegated to {}".format(orchestrator_name, target_name))
+
+      current_task = task_request
+      iteration = 0
+      final_output = None
+      task_complete = False
+
+      while iteration < max_iters and not task_complete:
+          iteration += 1
+
+          # Update spinner with current iteration
+          if spinner:
+              spinner.set_message("{} working (iter {}/{})".format(target_name, iteration, max_iters))
+
+          if iteration > 1:
+              print(colored("\n" + sep, "yellow"))
+              iter_msg = "  Iteration {}/{} - Re-tasking @{}".format(iteration, max_iters, target_name)
+              print(colored(iter_msg, "yellow", attrs=["bold"]))
+              print(colored(sep + "\n", "yellow"))
+
+          try:
+              result = target_npc.check_llm_command(
+                  current_task,
+                  context=context,
+                  team=team_obj,
+                  jinxs=target_jinxs,
+                  stream=False,
+              )
+
+              if isinstance(result, dict):
+                  delegate_output = result.get('output') or result.get('response') or str(result)
+                  delegate_messages = result.get('messages', [])
+              else:
+                  delegate_output = str(result)
+                  delegate_messages = []
+
+              print(colored("\n" + sep, "cyan"))
+              print(colored("  @{} iteration {} complete".format(target_name, iteration), "green"))
+              print(colored(sep + "\n", "cyan"))
+
+              # Update spinner for review phase
+              if spinner:
+                  spinner.set_message("{} reviewing {}'s work".format(orchestrator_name, target_name))
+
+              # Build review prompt without f-strings to avoid YAML issues
+              output_preview = delegate_output[:2000] if delegate_output else 'No output received'
+              msg_preview = str(delegate_messages[-5:]) if delegate_messages else 'No messages'
+
+              review_lines = [
+                  "You are reviewing work done by @{} on this task:".format(target_name),
+                  "",
+                  "ORIGINAL TASK: " + task_request,
+                  "",
+                  "ITERATION: {}/{}".format(iteration, max_iters),
+                  "",
+                  "SUB-AGENT OUTPUT:",
+                  output_preview,
+                  "",
+                  "RECENT MESSAGES:",
+                  msg_preview,
+                  "",
+                  "Evaluate if the task is complete. Consider:",
+                  "1. Did the sub-agent accomplish what was asked?",
+                  "2. Are there obvious errors or incomplete steps?",
+                  "3. For GUI tasks: Did they fill in all required fields?",
+                  "",
+                  "Respond EXACTLY like this:",
+                  "COMPLETE: YES or NO",
+                  "FEEDBACK: If NO, what should be done next",
+                  "SUMMARY: Brief summary of progress"
+              ]
+              review_prompt = "\n".join(review_lines)
+
+              review_result = get_llm_response(
+                  review_prompt,
+                  model=getattr(orchestrator, 'model', 'gemini-2.5-flash'),
+                  provider=getattr(orchestrator, 'provider', 'gemini'),
+                  npc=orchestrator,
+                  temperature=0.3
+              )
+
+              review_text = str(review_result.get('response', ''))
+              is_complete = 'COMPLETE: YES' in review_text.upper()
+
+              feedback = ""
+              if 'FEEDBACK:' in review_text:
+                  fb_start = review_text.find('FEEDBACK:') + 9
+                  fb_end = review_text.find('SUMMARY:', fb_start) if 'SUMMARY:' in review_text else len(review_text)
+                  feedback = review_text[fb_start:fb_end].strip()
+
+              summary = ""
+              if 'SUMMARY:' in review_text:
+                  summary = review_text[review_text.find('SUMMARY:') + 8:].strip()
+
+              if is_complete:
+                  task_complete = True
+                  print(colored("\n  Task completed successfully", "green", attrs=["bold"]))
+                  if summary:
+                      print(colored("  Summary: " + summary[:200], "white", attrs=["dark"]))
+                  final_output = "[{}] Task completed.\n{}".format(target_name, summary)
+              else:
+                  print(colored("\n  Task incomplete - providing feedback", "yellow"))
+                  if feedback:
+                      print(colored("  Feedback: " + feedback[:200] + "...", "white", attrs=["dark"]))
+
+                  followup_lines = [
+                      "Continue the previous task. Feedback from orchestrator:",
+                      "",
+                      "ORIGINAL TASK: " + task_request,
+                      "",
+                      "FEEDBACK: " + feedback,
+                      "",
+                      "Continue and complete the task based on this feedback."
+                  ]
+                  current_task = "\n".join(followup_lines)
+
+                  if delegate_messages:
+                      context['messages'] = delegate_messages
+
+          except Exception as e:
+              print(colored("  Error in iteration {}: {}".format(iteration, e), "red"))
+              final_output = "Error delegating to {}: {}".format(target_name, str(e))
+              break
+
+      if not task_complete and iteration >= max_iters:
+          print(colored("\n  Max iterations ({}) reached".format(max_iters), "yellow"))
+          status = summary if summary else 'Unknown'
+          final_output = "[{}] Task incomplete after {} iterations. Status: {}".format(target_name, max_iters, status)
+
+      output = final_output or "[{}]: No output received".format(target_name)