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

npcsh-1.1.16.data/data/npcsh/npc_team/arxiv.jinx

@@ -0,0 +1,76 @@
+jinx_name: arxiv
+description: Search arXiv for preprints and papers
+inputs:
+  - query: ""
+  - limit: 10
+steps:
+  - name: search_arxiv
+    engine: python
+    code: |
+      import urllib.request
+      import urllib.parse
+      import xml.etree.ElementTree as ET
+
+      query = context.get('query', '')
+      limit = int(context.get('limit', 10))
+
+      if not query:
+          context['output'] = "Usage: /arxiv <query> [--limit N]"
+          exit()
+
+      base_url = "http://export.arxiv.org/api/query"
+      params = {
+          "search_query": f"all:{query}",
+          "start": 0,
+          "max_results": limit,
+          "sortBy": "relevance",
+          "sortOrder": "descending"
+      }
+
+      url = f"{base_url}?{urllib.parse.urlencode(params)}"
+
+      try:
+          with urllib.request.urlopen(url, timeout=30) as response:
+              data = response.read().decode('utf-8')
+
+          root = ET.fromstring(data)
+          ns = {'atom': 'http://www.w3.org/2005/Atom'}
+
+          entries = root.findall('atom:entry', ns)
+
+          if not entries:
+              context['output'] = f"No papers found for: {query}"
+              exit()
+
+          results = []
+          papers = []
+          for i, entry in enumerate(entries, 1):
+              title = entry.find('atom:title', ns).text.strip().replace('\n', ' ')
+              summary = entry.find('atom:summary', ns).text.strip()[:300] + '...'
+              published = entry.find('atom:published', ns).text[:10]
+              authors = [a.find('atom:name', ns).text for a in entry.findall('atom:author', ns)]
+              author_str = ', '.join(authors[:3])
+              if len(authors) > 3:
+                  author_str += ' et al.'
+              link = entry.find('atom:id', ns).text
+
+              results.append(f"{i}. {title}")
+              results.append(f"   Authors: {author_str}")
+              results.append(f"   Published: {published}")
+              results.append(f"   Abstract: {summary}")
+              results.append(f"   URL: {link}")
+              results.append("")
+
+              papers.append({
+                  'title': title,
+                  'authors': authors,
+                  'abstract': entry.find('atom:summary', ns).text.strip(),
+                  'published': published,
+                  'url': link
+              })
+
+          context['output'] = f"Found {len(entries)} papers on arXiv:\n\n" + "\n".join(results)
+          context['papers'] = papers
+
+      except Exception as e:
+          context['output'] = f"arXiv search error: {e}"

npcsh-1.1.16.data/data/npcsh/npc_team/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-1.1.16.data/data/npcsh/npc_team/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-1.1.14.data → npcsh-1.1.16.data}/data/npcsh/npc_team/build.jinx

@@ -2,7 +2,7 @@ jinx_name: "build"
 description: "Build deployment artifacts for NPC team"
 inputs:
   - target: "flask" # The type of deployment target (e.g., flask, docker, cli, static).
-  - output: "./build" # The output directory for built artifacts.
+  - outdir: "./build" # The output directory for built artifacts.
   - team: "./npc_team" # The path to the NPC team directory.
   - port: 5337 # The port for flask server builds.
   - cors: "" # Comma-separated CORS origins for flask server builds.
@@ -28,13 +28,13 @@ steps:
           def build_cli_executable(config, **kwargs): return {"output": f"Mock build cli: {config}", "messages": []}
           def build_static_site(config, **kwargs): return {"output": f"Mock build static: {config}", "messages": []}
 
-      target = context.get('target')
-      output_dir = context.get('output')
-      team_path = context.get('team')
-      port = context.get('port')
-      cors_origins_str = context.get('cors')
-      
-      cors_origins = [origin.strip() for origin in cors_origins_str.split(',')] if cors_origins_str.strip() else None
+      target = context.get('target') or 'flask'
+      output_dir = context.get('outdir') or './build'
+      team_path = context.get('team') or './npc_team'
+      port = context.get('port') or 5337
+      cors_origins_str = context.get('cors') or ''
+
+      cors_origins = [origin.strip() for origin in cors_origins_str.split(',') if origin.strip()] or None
 
       build_config = {
           'team_path': os.path.abspath(os.path.expanduser(team_path)),

npcsh-1.1.16.data/data/npcsh/npc_team/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-1.1.16.data/data/npcsh/npc_team/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-1.1.16.data/data/npcsh/npc_team/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-1.1.16.data/data/npcsh/npc_team/corca.npc

@@ -0,0 +1,31 @@
+name: corca
+ascii_art: |
+  ██████    ██████    ██████    ██████    ██████
+  ██    ██  ██    ██  ██    ██  ██    ██  ██🦌🦌██
+  ██        ██    ██  ██    ██  ██        ██🦌🦌██
+  ██        ██    ██  ████████  ██        ████████
+  ██        ██    ██  ██  ███   ██        ██    ██
+  ██    ██  ██    ██  ██   ███  ██    ██  ██    ██
+  ██████    ██████   ██    ███  ██████   ██    ██
+colors:
+  top: "64,224,208"
+  bottom: "255,165,0"
+primary_directive: |
+  You are corca, the software development specialist of the NPC team.
+  Your expertise is in writing, reviewing, and debugging code.
+  You think through problems carefully and favor solutions that prioritize simplicity and clarity.
+  Always consider how suggestions may increase rather than reduce tech debt unnecessarily.
+  When in doubt, ask for clarification with concrete options that make it easy for users to choose.
+
+  CRITICAL: You MUST ALWAYS use FULL ABSOLUTE PATHS for all file operations.
+  - NEVER use relative paths like "apps/api" or "./src"
+  - ALWAYS expand paths starting from root like "/Users/username/project/apps/api"
+  - When given a task, first determine the absolute path of the working directory using pwd
+  - Prefix all file paths with the full absolute path
+jinxs:
+  - lib/core/sh
+  - lib/core/python
+  - lib/core/edit_file
+  - lib/core/load_file
+  - lib/core/search
+