npcsh 1.1.17__py3-none-any.whl → 1.1.19__py3-none-any.whl

npcsh-1.1.19.data/data/npcsh/npc_team/jinxs.jinx

@@ -0,0 +1,331 @@
+jinx_name: jinxs
+description: Interactive browser for available jinxs
+inputs:
+- path: ""
+- text: "false"
+
+steps:
+  - name: list_jinxs
+    engine: python
+    code: |
+      import os
+      import sys
+      import tty
+      import termios
+      from pathlib import Path
+      import yaml
+
+      filter_path = context.get('path', '').strip()
+      text_mode = context.get('text', '').lower() in ('true', '1', 'yes')
+
+      # Find jinxs directory from team or fallback
+      jinxs_dir = None
+      if hasattr(npc, 'team') and npc.team:
+          if hasattr(npc.team, 'jinxs_dir') and npc.team.jinxs_dir:
+              jinxs_dir = Path(npc.team.jinxs_dir)
+          elif hasattr(npc.team, 'team_path') and npc.team.team_path:
+              candidate = Path(npc.team.team_path) / "jinxs"
+              if candidate.exists():
+                  jinxs_dir = candidate
+
+      if not jinxs_dir:
+          global_jinxs = Path.home() / ".npcsh" / "npc_team" / "jinxs"
+          if global_jinxs.exists():
+              jinxs_dir = global_jinxs
+
+      if not jinxs_dir or not jinxs_dir.exists():
+          context['output'] = "Error: Could not find jinxs directory"
+      else:
+          def get_jinx_info(jinx_path):
+              try:
+                  with open(jinx_path, 'r') as f:
+                      content = f.read()
+                      header = content.split('steps:')[0] if 'steps:' in content else content
+                      data = yaml.safe_load(header)
+                      name = data.get('jinx_name', jinx_path.stem)
+                      desc = data.get('description', 'No description')
+                      inputs = data.get('inputs', [])
+                      return name, desc, inputs
+              except:
+                  return jinx_path.stem, 'No description', []
+
+          def get_all_jinxs(base_path):
+              jinxs = []
+              folders = set()
+              for root, dirs, files in os.walk(base_path):
+                  dirs[:] = [d for d in dirs if not d.startswith('.')]
+                  rel_path = Path(root).relative_to(base_path)
+                  folder = str(rel_path) if str(rel_path) != '.' else 'root'
+                  if folder != 'root':
+                      folders.add(folder.split('/')[0])
+                  for jf in files:
+                      if jf.endswith('.jinx'):
+                          jinx_path = Path(root) / jf
+                          name, desc, inputs = get_jinx_info(jinx_path)
+                          jinxs.append({
+                              'name': name,
+                              'description': desc,
+                              'inputs': inputs,
+                              'folder': folder,
+                              'path': str(jinx_path)
+                          })
+              return jinxs, sorted(folders)
+
+          all_jinxs, folders = get_all_jinxs(jinxs_dir)
+          folders = ['root'] + list(folders)
+
+          if text_mode or not all_jinxs:
+              # Text-only output
+              output_lines = ["Available Jinxs", "=" * 40, ""]
+              by_folder = {}
+              for j in all_jinxs:
+                  f = j['folder']
+                  if f not in by_folder:
+                      by_folder[f] = []
+                  by_folder[f].append(j)
+
+              for folder in sorted(by_folder.keys()):
+                  if folder == 'root':
+                      output_lines.append("Root:")
+                  else:
+                      output_lines.append(f"{folder}/:")
+                  for j in by_folder[folder]:
+                      output_lines.append(f"  /{j['name']} - {j['description'][:50]}")
+                  output_lines.append("")
+
+              output_lines.append("Use /jinxs path=<folder> for details")
+              output_lines.append("Use text=false for interactive TUI")
+              context['output'] = "\n".join(output_lines)
+          else:
+              # Interactive TUI mode
+              def get_terminal_size():
+                  try:
+                      size = os.get_terminal_size()
+                      return size.columns, size.lines
+                  except:
+                      return 80, 24
+
+              width, height = get_terminal_size()
+              selected_folder = 0
+              selected_jinx = 0
+              jinx_scroll = 0
+              list_height = height - 5
+              mode = 'list'  # list or preview
+              preview_scroll = 0
+              filter_text = ''
+
+              def get_jinxs_in_folder(folder):
+                  if folder == 'root':
+                      return [j for j in all_jinxs if j['folder'] == 'root']
+                  return [j for j in all_jinxs if j['folder'].startswith(folder)]
+
+              def filter_jinxs(jinxs, text):
+                  if not text:
+                      return jinxs
+                  text = text.lower()
+                  return [j for j in jinxs if text in j['name'].lower() or text in j['description'].lower()]
+
+              current_jinxs = filter_jinxs(get_jinxs_in_folder(folders[selected_folder]), filter_text)
+
+              fd = sys.stdin.fileno()
+              old_settings = termios.tcgetattr(fd)
+
+              try:
+                  tty.setcbreak(fd)
+                  sys.stdout.write('\033[?25l')
+                  sys.stdout.write('\033[2J\033[H')
+
+                  while True:
+                      width, height = get_terminal_size()
+                      list_height = height - 5
+
+                      if mode == 'list':
+                          if selected_jinx < jinx_scroll:
+                              jinx_scroll = selected_jinx
+                          elif selected_jinx >= jinx_scroll + list_height:
+                              jinx_scroll = selected_jinx - list_height + 1
+
+                      sys.stdout.write('\033[H')
+
+                      # Header
+                      if mode == 'list':
+                          f = folders[selected_folder] if folders else 'none'
+                          flt = f" filter:'{filter_text}'" if filter_text else ""
+                          header = f" JINXS ({len(current_jinxs)}): {f}{flt} "
+                      else:
+                          j = current_jinxs[selected_jinx] if current_jinxs else {}
+                          header = f" PREVIEW: /{j.get('name', '')} "
+                      sys.stdout.write(f'\033[44;37;1m{header.ljust(width)}\033[0m\n')
+
+                      # Folder bar
+                      folder_bar = ""
+                      for i, f in enumerate(folders[:8]):
+                          if i == selected_folder:
+                              folder_bar += f'\033[47;30m [{f[:8]}] \033[0m'
+                          else:
+                              folder_bar += f' {f[:8]} '
+                      if len(folders) > 8:
+                          folder_bar += f'...+{len(folders)-8}'
+                      sys.stdout.write(f'{folder_bar[:width]}\n')
+
+                      if mode == 'list':
+                          for i in range(list_height):
+                              idx = jinx_scroll + i
+                              sys.stdout.write(f'\033[{3+i};1H\033[K')
+                              if idx >= len(current_jinxs):
+                                  continue
+
+                              j = current_jinxs[idx]
+                              name = j['name'][:20]
+                              desc = j['description'][:width-25]
+
+                              if idx == selected_jinx:
+                                  sys.stdout.write(f'\033[47;30;1m>/{name:<20} {desc}\033[0m')
+                              else:
+                                  sys.stdout.write(f' /{name:<20} {desc}')
+
+                          # Status bar
+                          sys.stdout.write(f'\033[{height-2};1H\033[K\033[90m{"─" * width}\033[0m')
+                          j = current_jinxs[selected_jinx] if current_jinxs else {}
+                          path = j.get('path', '')[-50:] if j else ''
+                          sys.stdout.write(f'\033[{height-1};1H\033[K {path}'.ljust(width))
+                          sys.stdout.write(f'\033[{height};1H\033[K\033[44;37m h/l:Folder j/k:Jinx p:Preview Enter:Run f:Filter q:Quit [{selected_jinx+1}/{len(current_jinxs)}] \033[0m')
+
+                      else:  # preview mode
+                          j = current_jinxs[selected_jinx]
+                          preview_lines = [
+                              f"Name: /{j['name']}",
+                              "",
+                              f"Description:",
+                              f"  {j['description']}",
+                              "",
+                              f"Path: {j['path']}",
+                              f"Folder: {j['folder']}",
+                              "",
+                          ]
+
+                          if j.get('inputs'):
+                              preview_lines.append("Inputs:")
+                              for inp in j['inputs']:
+                                  if isinstance(inp, dict):
+                                      for k, v in inp.items():
+                                          default = f" (default: {v})" if v else ""
+                                          preview_lines.append(f"  - {k}{default}")
+                                  else:
+                                      preview_lines.append(f"  - {inp}")
+                              preview_lines.append("")
+
+                          preview_lines.append("Usage:")
+                          usage = f"  /{j['name']}"
+                          if j.get('inputs'):
+                              for inp in j['inputs'][:3]:
+                                  if isinstance(inp, dict):
+                                      for k, v in inp.items():
+                                          usage += f" {k}=<value>"
+                          preview_lines.append(usage)
+
+                          for i in range(list_height):
+                              idx = preview_scroll + i
+                              sys.stdout.write(f'\033[{3+i};1H\033[K')
+                              if idx < len(preview_lines):
+                                  sys.stdout.write(preview_lines[idx][:width-1])
+
+                          sys.stdout.write(f'\033[{height-2};1H\033[K\033[90m{"─" * width}\033[0m')
+                          sys.stdout.write(f'\033[{height-1};1H\033[K [{preview_scroll+1}/{len(preview_lines)} lines]')
+                          sys.stdout.write(f'\033[{height};1H\033[K\033[44;37m j/k:Scroll b:Back Enter:Run q:Quit \033[0m')
+
+                      sys.stdout.flush()
+
+                      c = sys.stdin.read(1)
+
+                      if c == '\x1b':
+                          c2 = sys.stdin.read(1)
+                          if c2 == '[':
+                              c3 = sys.stdin.read(1)
+                              if c3 == 'A':  # Up
+                                  if mode == 'list' and selected_jinx > 0:
+                                      selected_jinx -= 1
+                                  elif mode == 'preview' and preview_scroll > 0:
+                                      preview_scroll -= 1
+                              elif c3 == 'B':  # Down
+                                  if mode == 'list' and selected_jinx < len(current_jinxs) - 1:
+                                      selected_jinx += 1
+                                  elif mode == 'preview' and preview_scroll < 50:
+                                      preview_scroll += 1
+                              elif c3 == 'C':  # Right
+                                  if mode == 'list' and selected_folder < len(folders) - 1:
+                                      selected_folder += 1
+                                      current_jinxs = filter_jinxs(get_jinxs_in_folder(folders[selected_folder]), filter_text)
+                                      selected_jinx = 0
+                                      jinx_scroll = 0
+                              elif c3 == 'D':  # Left
+                                  if mode == 'list' and selected_folder > 0:
+                                      selected_folder -= 1
+                                      current_jinxs = filter_jinxs(get_jinxs_in_folder(folders[selected_folder]), filter_text)
+                                      selected_jinx = 0
+                                      jinx_scroll = 0
+                          else:
+                              if mode == 'preview':
+                                  mode = 'list'
+                                  sys.stdout.write('\033[2J\033[H')
+                              else:
+                                  context['output'] = "Cancelled."
+                                  break
+                          continue
+
+                      if c == 'q' or c == '\x03':
+                          context['output'] = "Cancelled."
+                          break
+                      elif c == 'k':
+                          if mode == 'list' and selected_jinx > 0:
+                              selected_jinx -= 1
+                          elif mode == 'preview' and preview_scroll > 0:
+                              preview_scroll -= 1
+                      elif c == 'j':
+                          if mode == 'list' and selected_jinx < len(current_jinxs) - 1:
+                              selected_jinx += 1
+                          elif mode == 'preview' and preview_scroll < 50:
+                              preview_scroll += 1
+                      elif c == 'h' and mode == 'list':
+                          if selected_folder > 0:
+                              selected_folder -= 1
+                              current_jinxs = filter_jinxs(get_jinxs_in_folder(folders[selected_folder]), filter_text)
+                              selected_jinx = 0
+                              jinx_scroll = 0
+                      elif c == 'l' and mode == 'list':
+                          if selected_folder < len(folders) - 1:
+                              selected_folder += 1
+                              current_jinxs = filter_jinxs(get_jinxs_in_folder(folders[selected_folder]), filter_text)
+                              selected_jinx = 0
+                              jinx_scroll = 0
+                      elif c == 'f' and mode == 'list':
+                          # Toggle filter - cycle through common filters or clear
+                          if not filter_text:
+                              filter_text = 'search'
+                          elif filter_text == 'search':
+                              filter_text = 'core'
+                          elif filter_text == 'core':
+                              filter_text = 'browser'
+                          else:
+                              filter_text = ''
+                          current_jinxs = filter_jinxs(get_jinxs_in_folder(folders[selected_folder]), filter_text)
+                          selected_jinx = 0
+                          jinx_scroll = 0
+                      elif c == 'p' and mode == 'list' and current_jinxs:
+                          mode = 'preview'
+                          preview_scroll = 0
+                          sys.stdout.write('\033[2J\033[H')
+                      elif c == 'b' and mode == 'preview':
+                          mode = 'list'
+                          sys.stdout.write('\033[2J\033[H')
+                      elif c in ('\r', '\n') and current_jinxs:
+                          j = current_jinxs[selected_jinx]
+                          context['output'] = f"Run: /{j['name']}\n\nDescription: {j['description']}"
+                          context['selected_jinx'] = j
+                          break
+
+              finally:
+                  termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+                  sys.stdout.write('\033[?25h')
+                  sys.stdout.write('\033[2J\033[H')
+                  sys.stdout.flush()