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

npcsh/npc_team/jinxs/bin/nql.jinx

@@ -1,141 +0,0 @@
-jinx_name: nql
-description: "Run NPC-SQL models with AI-powered transformations. Supports cron scheduling."
-inputs:
-- models_dir: "~/.npcsh/npc_team/models"
-- db: "~/npcsh_history.db"
-- model: ""
-- schema: ""
-- show: ""
-- cron: ""
-- install_cron: ""
-
-steps:
-  - name: run_nql
-    engine: python
-    code: |
-      import os
-      import sys
-      from pathlib import Path
-
-      models_dir = context.get('models_dir') or '~/.npcsh/npc_team/models'
-      db_path = context.get('db') or '~/npcsh_history.db'
-      model_name = context.get('model') or ''
-      schema = context.get('schema') or ''
-      list_models = context.get('show') or ''
-      cron_expr = context.get('cron') or ''
-      install_cron = context.get('install_cron') or ''
-
-      models_dir = os.path.expanduser(models_dir)
-      db_path = os.path.expanduser(db_path)
-
-      # Find NPC team directory
-      npc_dir = None
-      if os.path.exists('./npc_team'):
-          npc_dir = './npc_team'
-      elif os.path.exists(os.path.expanduser('~/.npcsh/npc_team')):
-          npc_dir = os.path.expanduser('~/.npcsh/npc_team')
-
-      # Import npcsql
-      try:
-          from npcpy.sql.npcsql import ModelCompiler, SQLModel
-      except ImportError:
-          output = "Error: npcpy.sql.npcsql not found. Install npcpy first."
-          raise SystemExit(1)
-
-      # List models mode
-      if list_models:
-          if not os.path.exists(models_dir):
-              output = "No models directory found at " + models_dir
-          else:
-              models_path = Path(models_dir)
-              sql_files = list(models_path.glob("**/*.sql"))
-              if not sql_files:
-                  output = "No .sql models found in " + models_dir
-              else:
-                  lines = ["Available NQL models in " + models_dir + ":", ""]
-                  for f in sorted(sql_files):
-                      rel = f.relative_to(models_path)
-                      # Check for nql functions
-                      with open(f, 'r') as fh:
-                          content = fh.read()
-                      has_nql = "nql." in content
-                      marker = " [NQL]" if has_nql else ""
-                      lines.append("  " + str(rel) + marker)
-                  output = "\n".join(lines)
-
-      # Install cron mode
-      elif install_cron:
-          import subprocess
-          # Parse cron expression and model
-          parts = install_cron.split()
-          if len(parts) < 5:
-              output = "Error: cron expression must have 5 fields (min hour day month weekday)"
-          else:
-              cron_time = " ".join(parts[:5])
-              cron_model = parts[5] if len(parts) > 5 else ""
-
-              # Build command
-              nql_cmd = "npc nql"
-              if cron_model:
-                  nql_cmd += " model=" + cron_model
-              nql_cmd += " models_dir=" + models_dir
-              nql_cmd += " db=" + db_path
-              if schema:
-                  nql_cmd += " schema=" + schema
-
-              cron_line = cron_time + " " + nql_cmd
-
-              # Get current crontab
-              try:
-                  result = subprocess.run(['crontab', '-l'], capture_output=True, text=True)
-                  current = result.stdout if result.returncode == 0 else ""
-              except:
-                  current = ""
-
-              # Check if already installed
-              if nql_cmd in current:
-                  output = "Cron job already exists for: " + nql_cmd
-              else:
-                  # Add new cron line
-                  new_crontab = current.rstrip() + "\n" + cron_line + "\n"
-                  proc = subprocess.run(['crontab', '-'], input=new_crontab, text=True, capture_output=True)
-                  if proc.returncode == 0:
-                      output = "Installed cron job:\n  " + cron_line
-                  else:
-                      output = "Failed to install cron: " + proc.stderr
-
-      # Run models mode
-      else:
-          if not os.path.exists(models_dir):
-              output = "Models directory not found: " + models_dir + "\nCreate it with: mkdir -p " + models_dir
-          else:
-              try:
-                  compiler = ModelCompiler(
-                      models_dir=models_dir,
-                      target_engine=db_path,
-                      npc_directory=npc_dir,
-                      target_schema=schema if schema else None
-                  )
-
-                  if model_name:
-                      # Run specific model
-                      compiler.discover_models()
-                      if model_name not in compiler.models:
-                          available = list(compiler.models.keys())
-                          output = "Model '" + model_name + "' not found. Available: " + str(available)
-                      else:
-                          print("Running model: " + model_name)
-                          df = compiler.execute_model(model_name)
-                          output = "Model '" + model_name + "' completed. Rows: " + str(len(df))
-                  else:
-                      # Run all models in dependency order
-                      results = compiler.run_all_models()
-                      lines = ["NQL run complete:", ""]
-                      for name, df in results.items():
-                          lines.append("  " + name + ": " + str(len(df)) + " rows")
-                      output = "\n".join(lines)
-
-              except Exception as e:
-                  output = "NQL Error: " + str(e)
-                  import traceback
-                  traceback.print_exc()

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/bin/vixynt.jinx

@@ -1,122 +0,0 @@
-jinx_name: "vixynt"
-description: "Generates images from text descriptions or edits existing ones."
-inputs:
-- prompt
-- model: null
-- provider: null
-- output_name: null
-- attachments: null
-- n_images: null
-- height: null
-- width: null
-steps:
-  - name: "generate_or_edit_image"
-    engine: "python"
-    code: |
-      import os
-      import base64
-      from io import BytesIO
-      from datetime import datetime
-      from PIL import Image
-      from npcpy.llm_funcs import gen_image
-      
-      # Extract inputs from context with proper type conversion
-      image_prompt = str(context.get('prompt', '')).strip()
-      output_name = context.get('output_name')
-      attachments_str = context.get('attachments')
-      
-      # Handle integer inputs - they may come as strings or ints
-      try:
-          n_images = int(context.get('n_images', 1))
-      except (ValueError, TypeError):
-          n_images = 1
-      
-      try:
-          height = int(context.get('height', 1024))
-      except (ValueError, TypeError):
-          height = 1024
-      
-      try:
-          width = int(context.get('width', 1024))
-      except (ValueError, TypeError):
-          width = 1024
-      
-      # Get model and provider from context or environment
-      model = context.get('model')
-      provider = context.get('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')
-      
-      # Parse attachments
-      input_images = []
-      if attachments_str and str(attachments_str).strip():
-          input_images = [p.strip() for p in str(attachments_str).split(',')]
-      
-      output_messages = context.get('messages', [])
-      
-      if not image_prompt:
-          output = "Error: No prompt provided for image generation."
-      else:
-          try:
-              # Generate image(s)
-              result = gen_image(
-                  prompt=image_prompt,
-                  model=model,
-                  provider=provider,
-                  npc=npc,
-                  height=height,
-                  width=width,
-                  n_images=n_images, 
-                  input_images=input_images if input_images else None
-              )
-              
-              # Ensure we have a list of images
-              if not isinstance(result, list):
-                  images_list = [result] if result is not None else []
-              else:
-                  images_list = result
-              
-              saved_files = []
-
-              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)))
-                      if not ext:
-                          ext = ".png"
-                      current_output_file = f"{base_name}_{i}{ext}" if len(images_list) > 1 else f"{base_name}{ext}"
-                  else:
-                      os.makedirs(os.path.expanduser("~/.npcsh/images/"), exist_ok=True)
-                      current_output_file = (
-                          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)
-
-              if saved_files:
-                  output = f"Image(s) generated: {', '.join(saved_files)}"
-                  if input_images:
-                      output = f"Image(s) edited: {', '.join(saved_files)}"
-                  context['generated_images'] = saved_files
-              else:
-                  output = "No images were generated."
-                  
-          except Exception as e:
-              import traceback
-              traceback.print_exc()
-              output = f"Error {'editing' if input_images else 'generating'} image: {str(e)}"
-      
-      context['output'] = output
-      context['messages'] = output_messages
-      context['model'] = model
-      context['provider'] = provider

npcsh/npc_team/jinxs/lib/core/search/mem_review.jinx

@@ -1,73 +0,0 @@
-jinx_name: mem_review
-description: Review pending memories with interactive UI
-inputs:
-- limit: "20"
-- npc_filter: ""
-- team_filter: ""
-- db_path: ""
-
-steps:
-  - name: review_memories
-    engine: python
-    code: |
-      import os
-      from npcpy.memory.command_history import CommandHistory
-      from npcpy.memory.memory_processor import memory_batch_review_ui
-
-      limit = int(context.get('limit') or 20)
-      npc_filter = context.get('npc_filter') or None
-      team_filter = context.get('team_filter') or None
-      db_path = context.get('db_path') or os.path.expanduser("~/npcsh_history.db")
-
-      # Get current npc/team from context if not specified
-      if not npc_filter:
-          try:
-              npc_filter = npc.name if 'npc' in dir() and npc else None
-          except:
-              pass
-
-      if not team_filter:
-          try:
-              team_filter = state.team.name if 'state' in dir() and state and state.team else None
-          except:
-              pass
-
-      try:
-          cmd_history = CommandHistory(db_path)
-
-          # Show what we're about to review
-          pending = cmd_history.get_pending_memories(limit=limit)
-          if npc_filter:
-              pending = [m for m in pending if m.get('npc') == npc_filter]
-          if team_filter:
-              pending = [m for m in pending if m.get('team') == team_filter]
-
-          if not pending:
-              context['output'] = "No pending memories to review."
-          else:
-              print(f"\nFound {len(pending)} pending memories")
-              if npc_filter:
-                  print(f"  NPC filter: {npc_filter}")
-              if team_filter:
-                  print(f"  Team filter: {team_filter}")
-
-              # Run interactive review
-              stats = memory_batch_review_ui(
-                  cmd_history,
-                  npc_filter=npc_filter,
-                  team_filter=team_filter,
-                  limit=limit
-              )
-
-              lines = [
-                  "Review complete:",
-                  f"  Approved: {stats.get('approved', 0)}",
-                  f"  Rejected: {stats.get('rejected', 0)}",
-                  f"  Edited:   {stats.get('edited', 0)}",
-                  f"  Skipped:  {stats.get('skipped', 0)}",
-              ]
-              context['output'] = "\n".join(lines)
-
-      except Exception as e:
-          import traceback
-          context['output'] = "Memory review error: " + str(e) + "\n" + traceback.format_exc()