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

{npcsh-1.1.14.data/data/npcsh/npc_team → npcsh/npc_team/jinxs/bin}/vixynt.jinx

@@ -41,27 +41,15 @@ steps:
       except (ValueError, TypeError):
           width = 1024
       
-      # Get model and provider, prioritizing context, then NPC, then environment variables
+      # Get model and provider from context or environment
       model = context.get('model')
       provider = context.get('provider')
-      
-      # Use NPC's model/provider as fallback
-      if not model and npc and hasattr(npc, 'model') and npc.model:
-          model = npc.model 
-      if not provider and npc and hasattr(npc, 'provider') and npc.provider:
-          provider = npc.provider
-      
+
       # Fallback to environment variables
       if not model:
           model = os.getenv('NPCSH_IMAGE_GEN_MODEL')
       if not provider:
           provider = os.getenv('NPCSH_IMAGE_GEN_PROVIDER')
-
-      # Final hardcoded fallbacks if nothing else is set
-      if not model:
-          model = "runwayml/stable-diffusion-v1-5"
-      if not provider:
-          provider = "diffusers"
       
       # Parse attachments
       input_images = []
@@ -93,12 +81,11 @@ steps:
                   images_list = result
               
               saved_files = []
-              html_image_tags = [] # This list will store the raw HTML <img> tags
-              
+
               for i, image in enumerate(images_list):
                   if image is None:
                       continue
-                  
+
                   # Determine output filename
                   if output_name and str(output_name).strip():
                       base_name, ext = os.path.splitext(os.path.expanduser(str(output_name)))
@@ -111,25 +98,16 @@ steps:
                           os.path.expanduser("~/.npcsh/images/")
                           + f"image_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{i}.png"
                       )
-                  
+
                   # Save image to file
                   image.save(current_output_file)
                   saved_files.append(current_output_file)
 
-                  # Convert image to base64 and create an HTML <img> tag
-                  with open(current_output_file, 'rb') as f:
-                      img_data = base64.b64encode(f.read()).decode()
-                      # Using raw HTML <img> tag with data URI
-                      html_image_tags.append(f'<img src="data:image/png;base64,{img_data}" alt="Generated Image {i+1}" style="max-width: 100%; display: block; margin-top: 10px;">')
-              
               if saved_files:
-                  output_text_message = f"Image(s) generated and saved to: {', '.join(saved_files)}"
+                  output = f"Image(s) generated: {', '.join(saved_files)}"
                   if input_images:
-                      output_text_message = f"Image(s) edited and saved to: {', '.join(saved_files)}"
-                  
-                  output = output_text_message # Keep the text message clean
-                  output += f"\n\nThe image files have been saved and are ready to view."
-                  output += "\n\n" + "\n".join(html_image_tags) # Append all HTML <img> tags to the output
+                      output = f"Image(s) edited: {', '.join(saved_files)}"
+                  context['generated_images'] = saved_files
               else:
                   output = "No images were generated."
                   

npcsh/npc_team/jinxs/bin/wander.jinx

@@ -0,0 +1,152 @@
+jinx_name: wander
+description: Creative daydreaming with probabilistic temperature shifts mid-stream
+inputs:
+  - problem
+steps:
+  - name: wander_explore
+    engine: python
+    code: |
+      import random
+      from termcolor import colored
+      from npcpy.llm_funcs import get_llm_response
+
+      problem = context.get('problem', '')
+      if not problem:
+          context['output'] = "Need a topic to wander about."
+          exit()
+
+      model = 'gpt-4.1-nano'
+      provider = 'openai'
+      low_temp = 0.5
+      high_temp = 1.9
+      sample_rate = 0.4
+      interrupt_prob = 0.02
+
+      print(f"""
+      ██╗    ██╗ █████╗ ███╗   ██╗██████╗ ███████╗██████╗
+      ██║    ██║██╔══██╗████╗  ██║██╔══██╗██╔════╝██╔══██╗
+      ██║ █╗ ██║███████║██╔██╗ ██║██║  ██║█████╗  ██████╔╝
+      ██║███╗██║██╔══██║██║╚██╗██║██║  ██║██╔══╝  ██╔══██╗
+      ╚███╔███╔╝██║  ██║██║ ╚████║██████╔╝███████╗██║  ██║
+       ╚══╝╚══╝ ╚═╝  ╚═╝╚═╝  ╚═══╝╚═════╝ ╚══════╝╚═╝  ╚═╝
+
+      Wandering: {problem}
+      """)
+
+      print(colored(f"--- Low temp stream ({low_temp}) ---", "cyan"))
+
+      low_prompt = f"Think about: {problem}"
+      resp = get_llm_response(low_prompt, model=model, provider=provider, temperature=low_temp, stream=True)
+
+      # Get the actual stream from the response
+      stream = resp.get('response') if isinstance(resp, dict) else resp
+
+      low_output = ""
+      interrupted = False
+
+      for chunk in stream:
+          if hasattr(chunk, 'choices') and chunk.choices:
+              delta = chunk.choices[0].delta
+              text = getattr(delta, 'content', '') or ''
+          elif isinstance(chunk, dict):
+              text = chunk.get('content', '') or chunk.get('response', '')
+          else:
+              text = ''
+
+          if text:
+              print(text, end='', flush=True)
+              low_output += text
+
+              if random.random() < interrupt_prob:
+                  print(colored("\n[INTERRUPT]", "yellow"))
+                  interrupted = True
+                  break
+
+      print()
+
+      print(colored(f"\n--- High temp stream ({high_temp}) ---", "cyan"))
+
+      high_prompt = f"{low_output}\n\nContinue:"
+      resp = get_llm_response(high_prompt, model=model, provider=provider, temperature=high_temp, stream=True)
+      stream = resp.get('response') if isinstance(resp, dict) else resp
+
+      high_output = ""
+      for chunk in stream:
+          if hasattr(chunk, 'choices') and chunk.choices:
+              delta = chunk.choices[0].delta
+              text = getattr(delta, 'content', '') or ''
+          elif isinstance(chunk, dict):
+              text = chunk.get('content', '') or chunk.get('response', '')
+          else:
+              text = ''
+
+          if text:
+              print(text, end='', flush=True)
+              high_output += text
+
+      print()
+
+      lines = [l for l in high_output.split('\n') if l.strip()]
+      sample_size = max(1, int(len(lines) * sample_rate))
+      sampled = random.sample(lines, sample_size) if lines else [high_output]
+
+      print(colored("\n=== SAMPLED INSIGHTS ===", "yellow"))
+      fragments_text = chr(10).join(sampled)
+      print(fragments_text)
+
+      print(colored("\n=== SYNTHESIS ===", "green"))
+
+      synthesis_prompt = f"""You are a mad scientist oracle. The gibberish below contains hidden truths.
+
+QUESTION: {problem}
+
+CHAOS FRAGMENTS:
+{fragments_text}
+
+RULES:
+1. You MUST use AT LEAST HALF of the fragments above - quote them directly
+2. Make WILD CREATIVE LEAPS - not academic, not safe, not obvious
+3. Find patterns in the noise like reading entrails or tea leaves
+4. Foreign text, Unicode garbage, code snippets - ALL are omens with meaning
+5. Puns, wordplay, phonetic similarities - all valid connections
+6. The weirder the connection, the better
+7. NO HEDGING. No "this suggests" or "perhaps". Be BOLD. Be CERTAIN.
+
+OUTPUT 3 WILD HYPOTHESES:
+For each: Quote the fragments you're using -> Make your creative leap -> State the bold claim
+
+These must be ideas that COULD NOT exist without this specific chaos. Surprise us. Make us see {problem} in a way nobody has before."""
+
+      resp = get_llm_response(synthesis_prompt, model=model, provider=provider, temperature=0.5, stream=True)
+      stream = resp.get('response') if isinstance(resp, dict) else resp
+
+      synthesis = ""
+      for chunk in stream:
+          if hasattr(chunk, 'choices') and chunk.choices:
+              delta = chunk.choices[0].delta
+              text = getattr(delta, 'content', '') or ''
+          elif isinstance(chunk, dict):
+              text = chunk.get('content', '') or chunk.get('response', '')
+          else:
+              text = ''
+
+          if text:
+              print(text, end='', flush=True)
+              synthesis += text
+
+      print()
+
+      full_output = f"""Wandering: {problem}
+
+        --- Low temp stream ({low_temp}) ---
+        {low_output}
+
+        --- High temp stream ({high_temp}) ---
+        {high_output}
+
+        === SAMPLED INSIGHTS ===
+        {fragments_text}
+
+        === SYNTHESIS ===
+        {synthesis}"""
+      context['output'] = full_output

npcsh/npc_team/jinxs/lib/browser/browser_action.jinx

@@ -0,0 +1,220 @@
+jinx_name: browser_action
+description: |
+  Perform an action in the browser. Actions:
+  - click: Click element
+  - type: Type text into element (clears first)
+  - type_and_enter: Type text and press Enter
+  - set_value: Force set value via JS (bypasses date pickers/validation)
+  - select: Select dropdown option by visible text
+  - wait: Wait for element to appear
+  - scroll: Scroll page (up/down/to element)
+  - get_text: Get text from element
+  - get_page: Get page title, URL, and visible text
+  - get_elements: Get interactive elements with their selectors
+  - press_key: Press a key (enter, tab, escape, etc)
+  Selectors: CSS (#id, .class, input[name="x"]) or xpath://... for XPath
+inputs:
+  - action:
+      description: "Action: click, type, type_and_enter, set_value, select, wait, scroll, get_text, get_page, get_elements, press_key"
+  - selector:
+      description: "CSS selector or XPath (prefix xpath: for XPath)"
+      default: ""
+  - value:
+      description: "Value for type/select, or scroll direction, or key name"
+      default: ""
+
+steps:
+  - name: browser_action
+    engine: python
+    code: |
+      from selenium.webdriver.common.by import By
+      from selenium.webdriver.support.ui import WebDriverWait, Select
+      from selenium.webdriver.support import expected_conditions as EC
+      from selenium.webdriver.common.keys import Keys
+      from npcpy.work.browser import get_current_driver
+
+      action = context.get('action', '').lower()
+      selector = context.get('selector', '')
+      value = context.get('value', '')
+
+      driver = get_current_driver()
+      if not driver:
+          output = "No active browser. Use open_browser first."
+          exit()
+
+      def find_element(sel):
+          if sel.startswith('xpath:'):
+              return driver.find_element(By.XPATH, sel[6:])
+          else:
+              return driver.find_element(By.CSS_SELECTOR, sel)
+
+      def wait_for_element(sel, timeout=10):
+          if sel.startswith('xpath:'):
+              return WebDriverWait(driver, timeout).until(
+                  EC.presence_of_element_located((By.XPATH, sel[6:]))
+              )
+          else:
+              return WebDriverWait(driver, timeout).until(
+                  EC.presence_of_element_located((By.CSS_SELECTOR, sel))
+              )
+
+      try:
+          if action == 'click':
+              elem = wait_for_element(selector)
+              elem.click()
+              output = "Clicked: {}".format(selector)
+
+          elif action == 'type':
+              elem = wait_for_element(selector)
+              elem.click()  # Focus first
+              elem.clear()
+              elem.send_keys(value)
+              output = "Typed '{}' into {}".format(value, selector)
+
+          elif action == 'set_value':
+              # Force set value via JS, bypasses validation/calendars
+              elem = wait_for_element(selector)
+              driver.execute_script("arguments[0].value = arguments[1]; arguments[0].dispatchEvent(new Event('input', {bubbles: true})); arguments[0].dispatchEvent(new Event('change', {bubbles: true}));", elem, value)
+              output = "Set value '{}' on {}".format(value, selector)
+
+          elif action == 'type_and_enter':
+              elem = wait_for_element(selector)
+              elem.clear()
+              elem.send_keys(value)
+              elem.send_keys(Keys.RETURN)
+              output = "Typed '{}' and pressed Enter".format(value)
+
+          elif action == 'select':
+              elem = wait_for_element(selector)
+              select = Select(elem)
+              select.select_by_visible_text(value)
+              output = "Selected '{}' in {}".format(value, selector)
+
+          elif action == 'wait':
+              timeout = int(value) if value else 10
+              wait_for_element(selector, timeout)
+              output = "Element found: {}".format(selector)
+
+          elif action == 'scroll':
+              if value == 'down':
+                  driver.execute_script("window.scrollBy(0, 500)")
+              elif value == 'up':
+                  driver.execute_script("window.scrollBy(0, -500)")
+              elif selector:
+                  elem = find_element(selector)
+                  driver.execute_script("arguments[0].scrollIntoView();", elem)
+              output = "Scrolled {}".format(value or 'to element')
+
+          elif action == 'get_text':
+              elem = wait_for_element(selector)
+              output = "Text: {}".format(elem.text)
+
+          elif action == 'get_page':
+              title = driver.title
+              url = driver.current_url
+              body = driver.find_element(By.TAG_NAME, 'body')
+              text = body.text[:3000]
+              output = "Page: {} ({})\n\nContent:\n{}".format(title, url, text)
+
+          elif action == 'get_elements':
+              elements = []
+
+              def is_visible(el):
+                  try:
+                      return el.is_displayed() and el.size['width'] > 0
+                  except:
+                      return False
+
+              def safe_selector(tag, el):
+                  eid = el.get_attribute('id')
+                  name = el.get_attribute('name')
+                  if eid and '.' not in eid and ' ' not in eid:
+                      return '#' + eid
+                  elif eid:
+                      return '{}[id="{}"]'.format(tag, eid)
+                  elif name:
+                      return '{}[name="{}"]'.format(tag, name)
+                  return None
+
+              # Get inputs
+              for inp in driver.find_elements(By.CSS_SELECTOR, 'input:not([type="hidden"])'):
+                  if not is_visible(inp):
+                      continue
+                  sel = safe_selector('input', inp)
+                  if not sel:
+                      ph = inp.get_attribute('placeholder')
+                      if ph:
+                          sel = 'input[placeholder="{}"]'.format(ph)
+                      else:
+                          continue
+                  info = {'tag': 'input', 'type': inp.get_attribute('type') or 'text', 'selector': sel}
+                  info['placeholder'] = inp.get_attribute('placeholder') or ''
+                  elements.append(info)
+
+              # Get buttons
+              for btn in driver.find_elements(By.CSS_SELECTOR, 'button, input[type="submit"], input[type="button"]'):
+                  if not is_visible(btn):
+                      continue
+                  sel = safe_selector('button', btn)
+                  if not sel and btn.text:
+                      sel = 'xpath://button[contains(text(),"{}")]'.format(btn.text[:30])
+                  if not sel:
+                      continue
+                  info = {'tag': 'button', 'selector': sel, 'text': (btn.text or '')[:50]}
+                  elements.append(info)
+
+              # Get select dropdowns
+              for s in driver.find_elements(By.TAG_NAME, 'select'):
+                  if not is_visible(s):
+                      continue
+                  sel = safe_selector('select', s)
+                  if not sel:
+                      continue
+                  opts = [o.text for o in s.find_elements(By.TAG_NAME, 'option')[:5]]
+                  info = {'tag': 'select', 'selector': sel, 'options': opts}
+                  elements.append(info)
+
+              # Get links
+              for link in driver.find_elements(By.TAG_NAME, 'a')[:30]:
+                  if not is_visible(link) or not link.text or len(link.text) < 2:
+                      continue
+                  sel = safe_selector('a', link)
+                  if not sel:
+                      sel = 'xpath://a[contains(text(),"{}")]'.format(link.text[:30])
+                  info = {'tag': 'a', 'selector': sel, 'text': link.text[:50]}
+                  elements.append(info)
+
+              output = "Found {} visible elements:\n".format(len(elements))
+              for el in elements[:40]:
+                  output += "{}: {} ".format(el['tag'], el.get('selector', ''))
+                  if el.get('text'):
+                      output += '"{}" '.format(el['text'][:30])
+                  if el.get('placeholder'):
+                      output += 'placeholder="{}" '.format(el['placeholder'])
+                  if el.get('options'):
+                      output += "opts={} ".format(el['options'][:3])
+                  output += "\n"
+
+          elif action == 'press_key':
+              key_map = {
+                  'enter': Keys.RETURN, 'return': Keys.RETURN,
+                  'tab': Keys.TAB,
+                  'escape': Keys.ESCAPE, 'esc': Keys.ESCAPE,
+                  'down': Keys.DOWN, 'up': Keys.UP,
+                  'left': Keys.LEFT, 'right': Keys.RIGHT,
+                  'backspace': Keys.BACKSPACE,
+                  'delete': Keys.DELETE,
+              }
+              key = key_map.get(value.lower(), value)
+              if selector:
+                  elem = find_element(selector)
+                  elem.send_keys(key)
+              else:
+                  driver.find_element(By.TAG_NAME, 'body').send_keys(key)
+              output = "Pressed key: {}".format(value)
+
+          else:
+              output = "Unknown action: {}".format(action)
+
+      except Exception as e:
+          output = "Browser action failed: {}".format(str(e))

npcsh/npc_team/jinxs/lib/browser/browser_screenshot.jinx

@@ -0,0 +1,40 @@
+jinx_name: browser_screenshot
+description: Take a screenshot of the current browser page.
+inputs:
+  - filename:
+      description: "Optional filename for screenshot"
+      default: ""
+
+steps:
+  - name: browser_screenshot
+    engine: python
+    code: |
+      import os
+      from datetime import datetime
+      from npcpy.work.browser import get_current_driver
+
+      filename = context.get('filename', '')
+
+      driver = get_current_driver()
+      if not driver:
+          output = "No active browser. Use open_browser first."
+          exit()
+
+      try:
+          screenshots_dir = os.path.expanduser('~/.npcsh/screenshots')
+          os.makedirs(screenshots_dir, exist_ok=True)
+
+          if not filename:
+              timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+              filename = "browser_{}.png".format(timestamp)
+
+          if not filename.endswith('.png'):
+              filename += '.png'
+
+          filepath = os.path.join(screenshots_dir, filename)
+          driver.save_screenshot(filepath)
+
+          output = "Screenshot saved: {}".format(filepath)
+
+      except Exception as e:
+          output = "Screenshot failed: {}".format(str(e))

npcsh/npc_team/jinxs/lib/browser/close_browser.jinx

@@ -0,0 +1,14 @@
+jinx_name: close_browser
+description: Close the current browser session.
+inputs: []
+
+steps:
+  - name: close_browser
+    engine: python
+    code: |
+      from npcpy.work.browser import close_current
+
+      if close_current():
+          output = "Browser closed."
+      else:
+          output = "No active browser session."

npcsh/npc_team/jinxs/lib/browser/open_browser.jinx

@@ -0,0 +1,43 @@
+jinx_name: open_browser
+description: |
+  Open a browser and navigate to a URL. The browser stays open for follow-up commands.
+  Use this to start browser automation.
+inputs:
+  - url:
+      description: "URL to navigate to"
+  - browser: "firefox"
+
+steps:
+  - name: open_browser
+    engine: python
+    code: |
+      from selenium import webdriver
+      from selenium.webdriver.firefox.service import Service as FirefoxService
+      from selenium.webdriver.chrome.service import Service as ChromeService
+      from webdriver_manager.firefox import GeckoDriverManager
+      from webdriver_manager.chrome import ChromeDriverManager
+      from npcpy.work.browser import set_driver
+      import uuid
+
+      url = context.get('url', '')
+      browser_type = context.get('browser', 'firefox').lower()
+
+      try:
+          if browser_type == 'chrome':
+              options = webdriver.ChromeOptions()
+              options.add_argument('--start-maximized')
+              driver = webdriver.Chrome(service=ChromeService(ChromeDriverManager().install()), options=options)
+          else:
+              options = webdriver.FirefoxOptions()
+              driver = webdriver.Firefox(service=FirefoxService(GeckoDriverManager().install()), options=options)
+              driver.maximize_window()
+
+          driver.get(url)
+
+          session_id = str(uuid.uuid4())[:8]
+          set_driver(session_id, driver)
+
+          output = "Browser opened. Session: {}. Navigated to: {}. Title: {}".format(session_id, url, driver.title)
+      except Exception as e:
+          import traceback
+          output = "Failed to open browser: {}\n{}".format(str(e), traceback.format_exc())

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

@@ -0,0 +1,23 @@
+jinx_name: click
+description: Click at screen coordinates (0-100 percentage)
+inputs:
+  - x: 50  # X coordinate as percentage (0-100)
+  - y: 50  # Y coordinate as percentage (0-100)
+
+steps:
+  - name: perform_click
+    engine: python
+    code: |
+      from npcpy.work.desktop import perform_action
+
+      x = float(context.get('x', 50))
+      y = float(context.get('y', 50))
+      messages = context.get('messages', [])
+
+      try:
+          perform_action({'type': 'click', 'x': x, 'y': y})
+          context['output'] = f"Clicked at ({x}%, {y}%)"
+      except Exception as e:
+          context['output'] = f"Click failed: {e}"
+
+      context['messages'] = messages

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

@@ -0,0 +1,26 @@
+jinx_name: key_press
+description: |
+  Press a keyboard key or key combination.
+  Valid keys: enter, tab, escape, backspace, delete, space, up, down, left, right,
+  home, end, pageup, pagedown, f1-f12, ctrl, alt, shift, command.
+  For combinations use + like: ctrl+a, ctrl+c, ctrl+v, alt+tab, ctrl+shift+t
+  For regular letters/numbers, use type_text instead.
+inputs:
+  - key: "enter"
+
+steps:
+  - name: perform_key
+    engine: python
+    code: |
+      from npcpy.work.desktop import perform_action
+
+      key = context.get('key', 'enter')
+      messages = context.get('messages', [])
+
+      try:
+          perform_action({'type': 'key', 'keys': key})
+          context['output'] = "Pressed key: " + str(key)
+      except Exception as e:
+          context['output'] = "Key press failed: " + str(e)
+
+      context['messages'] = messages

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

@@ -0,0 +1,37 @@
+jinx_name: launch_app
+description: Launch an application on the system
+inputs:
+  - command: ""  # Command to launch (e.g., "open -a Firefox" on macOS)
+
+steps:
+  - name: perform_launch
+    engine: python
+    code: |
+      import platform
+      from npcpy.work.desktop import perform_action
+
+      command = context.get('command', '')
+      messages = context.get('messages', [])
+
+      if not command:
+          system = platform.system()
+          if system == "Darwin":
+              examples = "open -a Firefox, open -a TextEdit"
+          elif system == "Windows":
+              examples = "start firefox, notepad, calc"
+          else:
+              examples = "firefox &, gedit &"
+          context['output'] = f"Usage: /launch_app <command>\nExamples: {examples}"
+          context['messages'] = messages
+          exit()
+
+      try:
+          result = perform_action({'type': 'bash', 'command': command})
+          if result.get('status') == 'success':
+              context['output'] = f"Launched: {command}"
+          else:
+              context['output'] = f"Launch failed: {result.get('message', 'unknown error')}"
+      except Exception as e:
+          context['output'] = f"Launch failed: {e}"
+
+      context['messages'] = messages

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

@@ -0,0 +1,23 @@
+jinx_name: screenshot
+description: Capture a screenshot of the current screen
+inputs:
+  - output_path: null  # Optional path to save screenshot
+
+steps:
+  - name: capture_screenshot
+    engine: python
+    code: |
+      from npcpy.data.image import capture_screenshot
+
+      output_path = context.get('output_path')
+      messages = context.get('messages', [])
+
+      result = capture_screenshot(full=True)
+
+      if result and 'file_path' in result:
+          context['output'] = f"Screenshot saved to: {result['file_path']}"
+          context['screenshot_path'] = result['file_path']
+      else:
+          context['output'] = "Failed to capture screenshot"
+
+      context['messages'] = messages