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

npcsh/npc_team/jinxs/bin/team_tui.jinx

@@ -1,327 +0,0 @@
-jinx_name: team_tui
-description: Interactive TUI for managing team context, NPCs, and jinxs
-inputs: []
-steps:
-  - name: team_manager
-    engine: python
-    code: |
-      import os
-      import sys
-      import tty
-      import termios
-      import select
-      import yaml
-      from pathlib import Path
-
-      if not sys.stdin.isatty():
-          context['output'] = "Team TUI requires an interactive terminal."
-          return
-
-      team = context.get('team')
-      if not team:
-          context['output'] = "No team loaded."
-          return
-
-      # ========== State ==========
-      class TeamState:
-          def __init__(self):
-              self.tab = 0  # 0=Team Context, 1=NPCs, 2=Jinxs
-              self.tabs = ['Team Context', 'NPCs', 'Jinxs']
-              self.selected_idx = 0
-              self.scroll_offset = 0
-              self.editing = False
-              self.edit_field = None
-              self.edit_buffer = ""
-              self.edit_cursor = 0
-              self.status = ""
-              self.team_ctx = {}
-              self.npcs = []
-              self.jinxs = []
-
-      state = TeamState()
-
-      # ========== Helpers ==========
-      def get_size():
-          try:
-              s = os.get_terminal_size()
-              return s.columns, s.lines
-          except:
-              return 80, 24
-
-      def load_team_data():
-          """Load team context, NPCs, and jinxs."""
-          # Load team.ctx
-          if hasattr(team, 'team_ctx'):
-              state.team_ctx = team.team_ctx or {}
-          else:
-              ctx_path = Path(team.team_path) / 'team.ctx'
-              if ctx_path.exists():
-                  with open(ctx_path) as f:
-                      state.team_ctx = yaml.safe_load(f) or {}
-
-          # Load NPCs
-          if hasattr(team, 'npcs'):
-              state.npcs = list(team.npcs.keys())
-          else:
-              npc_dir = Path(team.team_path)
-              state.npcs = [f.stem for f in npc_dir.glob('*.npc')]
-
-          # Load Jinxs count by folder
-          jinxs_dir = Path(team.team_path) / 'jinxs'
-          state.jinxs = []
-          if jinxs_dir.exists():
-              for subdir in sorted(jinxs_dir.iterdir()):
-                  if subdir.is_dir():
-                      count = len(list(subdir.glob('*.jinx')))
-                      state.jinxs.append((subdir.name, count))
-
-      def save_team_ctx():
-          """Save team.ctx file."""
-          ctx_path = Path(team.team_path) / 'team.ctx'
-          with open(ctx_path, 'w') as f:
-              yaml.dump(state.team_ctx, f, default_flow_style=False)
-          state.status = "Team context saved!"
-
-      # ========== Rendering ==========
-      def render_screen():
-          width, height = get_size()
-          out = []
-          out.append("\033[2J\033[H")
-
-          # Header
-          team_name = getattr(team, 'name', 'Unknown')
-          header = f" Team: {team_name} "
-          out.append(f"\033[1;1H\033[44;37;1m{'=' * width}\033[0m")
-          out.append(f"\033[1;{(width - len(header)) // 2}H\033[44;37;1m{header}\033[0m")
-
-          # Tabs
-          tab_str = ""
-          for i, tab in enumerate(state.tabs):
-              if i == state.tab:
-                  tab_str += f"\033[47;30m [{tab}] \033[0m"
-              else:
-                  tab_str += f" [{tab}] "
-          out.append(f"\033[2;2H{tab_str}")
-
-          # Content area
-          out.append(f"\033[3;1H\033[90m{'─' * width}\033[0m")
-
-          if state.tab == 0:
-              render_team_ctx(out, width, height)
-          elif state.tab == 1:
-              render_npcs(out, width, height)
-          elif state.tab == 2:
-              render_jinxs(out, width, height)
-
-          # Status
-          if state.status:
-              out.append(f"\033[{height-2};2H\033[33m{state.status}\033[0m")
-
-          # Footer
-          if state.editing:
-              footer = "[Enter] Save  [Esc] Cancel"
-          else:
-              footer = "[Tab] Switch Tab  [j/k] Navigate  [e] Edit  [s] Save  [q] Quit"
-          out.append(f"\033[{height};1H\033[90m{footer[:width]}\033[0m")
-
-          sys.stdout.write(''.join(out))
-          sys.stdout.flush()
-
-      def render_team_ctx(out, width, height):
-          """Render team context tab."""
-          fields = [
-              ('forenpc', 'Forenpc'),
-              ('model', 'Model'),
-              ('provider', 'Provider'),
-              ('context', 'Context'),
-          ]
-
-          row = 5
-          for i, (key, label) in enumerate(fields):
-              value = state.team_ctx.get(key, '')
-              if isinstance(value, str) and len(value) > 50:
-                  value = value[:50] + '...'
-
-              if i == state.selected_idx:
-                  if state.editing:
-                      out.append(f"\033[{row};4H\033[1m{label}:\033[0m")
-                      out.append(f"\033[{row+1};6H{state.edit_buffer[:width-10]}\033[7m \033[0m")
-                      row += 2
-                  else:
-                      out.append(f"\033[{row};4H\033[47;30m{label}: {value}\033[0m")
-                      row += 1
-              else:
-                  if value:
-                      out.append(f"\033[{row};4H{label}: \033[32m{value}\033[0m")
-                  else:
-                      out.append(f"\033[{row};4H{label}: \033[90m(not set)\033[0m")
-                  row += 1
-
-      def render_npcs(out, width, height):
-          """Render NPCs tab."""
-          visible_height = height - 8
-          visible = state.npcs[state.scroll_offset:state.scroll_offset + visible_height]
-
-          row = 5
-          for i, npc_name in enumerate(visible):
-              idx = i + state.scroll_offset
-              npc_obj = team.npcs.get(npc_name) if hasattr(team, 'npcs') else None
-
-              if npc_obj:
-                  model_info = f"{npc_obj.model or 'default'}/{npc_obj.provider or 'default'}"
-              else:
-                  model_info = ""
-
-              if idx == state.selected_idx:
-                  out.append(f"\033[{row};4H\033[47;30m> {npc_name:<15} {model_info}\033[0m")
-              else:
-                  out.append(f"\033[{row};4H  {npc_name:<15} \033[90m{model_info}\033[0m")
-              row += 1
-
-          if not state.npcs:
-              out.append(f"\033[5;4H\033[90mNo NPCs found in team.\033[0m")
-
-      def render_jinxs(out, width, height):
-          """Render Jinxs tab."""
-          visible_height = height - 8
-          visible = state.jinxs[state.scroll_offset:state.scroll_offset + visible_height]
-
-          row = 5
-          for i, (folder, count) in enumerate(visible):
-              idx = i + state.scroll_offset
-              if idx == state.selected_idx:
-                  out.append(f"\033[{row};4H\033[47;30m> {folder}/ ({count} jinxs)\033[0m")
-              else:
-                  out.append(f"\033[{row};4H  {folder}/ \033[90m({count} jinxs)\033[0m")
-              row += 1
-
-          if not state.jinxs:
-              out.append(f"\033[5;4H\033[90mNo jinxs folders found.\033[0m")
-
-      # ========== Input Handling ==========
-      def handle_input(c):
-          if state.editing:
-              return handle_edit_input(c)
-
-          if c == 'q':
-              return False
-
-          if c == '\t':  # Tab - switch tabs
-              state.tab = (state.tab + 1) % len(state.tabs)
-              state.selected_idx = 0
-              state.scroll_offset = 0
-              state.status = ""
-
-          elif c == '\x1b':  # Escape sequence
-              if select.select([sys.stdin], [], [], 0.05)[0]:
-                  c2 = sys.stdin.read(1)
-                  if c2 == '[':
-                      c3 = sys.stdin.read(1)
-                      if c3 == 'A':  # Up
-                          move_up()
-                      elif c3 == 'B':  # Down
-                          move_down()
-
-          elif c == 'k':
-              move_up()
-          elif c == 'j':
-              move_down()
-          elif c == 'e' or c == '\r' or c == '\n':
-              start_edit()
-          elif c == 's':
-              save_team_ctx()
-
-          return True
-
-      def handle_edit_input(c):
-          if c == '\x1b':  # Escape - cancel
-              state.editing = False
-              state.edit_buffer = ""
-              state.status = "Edit cancelled"
-              return True
-
-          if c == '\r' or c == '\n':  # Enter - save
-              if state.edit_field:
-                  state.team_ctx[state.edit_field] = state.edit_buffer
-                  state.status = f"Updated {state.edit_field}"
-              state.editing = False
-              state.edit_buffer = ""
-              state.edit_field = None
-              return True
-
-          if c == '\x7f' or c == '\x08':  # Backspace
-              if state.edit_cursor > 0:
-                  state.edit_buffer = state.edit_buffer[:state.edit_cursor-1] + state.edit_buffer[state.edit_cursor:]
-                  state.edit_cursor -= 1
-
-          elif c >= ' ' and c <= '~':  # Printable
-              state.edit_buffer = state.edit_buffer[:state.edit_cursor] + c + state.edit_buffer[state.edit_cursor:]
-              state.edit_cursor += 1
-
-          return True
-
-      def move_up():
-          state.selected_idx = max(0, state.selected_idx - 1)
-          if state.selected_idx < state.scroll_offset:
-              state.scroll_offset = state.selected_idx
-          state.status = ""
-
-      def move_down():
-          _, height = get_size()
-          visible_height = height - 8
-
-          if state.tab == 0:
-              max_idx = 3  # 4 fields in team ctx
-          elif state.tab == 1:
-              max_idx = len(state.npcs) - 1
-          else:
-              max_idx = len(state.jinxs) - 1
-
-          state.selected_idx = min(max_idx, state.selected_idx + 1)
-          if state.selected_idx >= state.scroll_offset + visible_height:
-              state.scroll_offset = state.selected_idx - visible_height + 1
-          state.status = ""
-
-      def start_edit():
-          if state.tab == 0:
-              fields = ['forenpc', 'model', 'provider', 'context']
-              if state.selected_idx < len(fields):
-                  state.edit_field = fields[state.selected_idx]
-                  state.edit_buffer = str(state.team_ctx.get(state.edit_field, ''))
-                  state.edit_cursor = len(state.edit_buffer)
-                  state.editing = True
-                  state.status = "Editing..."
-          elif state.tab == 1:
-              if state.npcs and state.selected_idx < len(state.npcs):
-                  npc_name = state.npcs[state.selected_idx]
-                  state.status = f"Selected NPC: {npc_name} (edit NPC files directly)"
-          elif state.tab == 2:
-              if state.jinxs and state.selected_idx < len(state.jinxs):
-                  folder, _ = state.jinxs[state.selected_idx]
-                  state.status = f"Selected folder: {folder}/"
-
-      # ========== Main Loop ==========
-      load_team_data()
-
-      fd = sys.stdin.fileno()
-      old_settings = termios.tcgetattr(fd)
-
-      try:
-          tty.setcbreak(fd)
-          sys.stdout.write('\033[?25l')  # Hide cursor
-
-          render_screen()
-
-          while True:
-              c = sys.stdin.read(1)
-              if not handle_input(c):
-                  break
-              render_screen()
-
-      finally:
-          termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
-          sys.stdout.write('\033[?25h')  # Show cursor
-          sys.stdout.write('\033[2J\033[H')  # Clear screen
-          sys.stdout.flush()
-
-      context['output'] = "Team manager closed."

npcsh/npc_team/jinxs/lib/utils/jinxs.jinx

@@ -1,331 +0,0 @@
-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()