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

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

@@ -0,0 +1,240 @@
+jinx_name: setup
+description: Interactive setup wizard for npcsh - detect local models, configure defaults
+inputs:
+  - skip_detection: ""
+steps:
+  - name: setup_wizard
+    engine: python
+    code: |
+      import os
+      import sys
+      import tty
+      import termios
+      import select
+      from pathlib import Path
+
+      if not sys.stdin.isatty():
+          context['output'] = "Setup wizard requires an interactive terminal."
+
+      else:
+          def detect_ollama_models():
+              models = []
+              try:
+                  import ollama
+                  result = ollama.list()
+                  for model in result.get('models', []):
+                      name = model.get('model', model.get('name', ''))
+                      if name:
+                          models.append(('ollama', name))
+              except:
+                  pass
+              return models
+
+          def detect_lm_studio_models():
+              models = []
+              try:
+                  import requests
+                  resp = requests.get('http://localhost:1234/v1/models', timeout=2)
+                  if resp.status_code == 200:
+                      data = resp.json()
+                      for m in data.get('data', []):
+                          models.append(('lm_studio', m.get('id', '')))
+              except:
+                  pass
+              return models
+
+          def detect_api_keys():
+              keys = {}
+              for key in ['ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'GEMINI_API_KEY', 'DEEPSEEK_API_KEY']:
+                  if os.environ.get(key):
+                      keys[key] = True
+              return keys
+
+          def get_cloud_models(api_keys):
+              models = []
+              if api_keys.get('ANTHROPIC_API_KEY'):
+                  models.extend([
+                      ('anthropic', 'claude-sonnet-4-20250514'),
+                      ('anthropic', 'claude-3-5-haiku-20241022'),
+                  ])
+              if api_keys.get('OPENAI_API_KEY'):
+                  models.extend([
+                      ('openai', 'gpt-4o'),
+                      ('openai', 'gpt-4o-mini'),
+                  ])
+              if api_keys.get('GEMINI_API_KEY'):
+                  models.extend([
+                      ('gemini', 'gemini-2.0-flash'),
+                      ('gemini', 'gemini-1.5-pro'),
+                  ])
+              if api_keys.get('DEEPSEEK_API_KEY'):
+                  models.extend([
+                      ('deepseek', 'deepseek-chat'),
+                  ])
+              return models
+
+          class SetupState:
+              def __init__(self):
+                  self.phase = 'detect'
+                  self.local_models = []
+                  self.cloud_models = []
+                  self.api_keys = {}
+                  self.providers_status = {}
+                  self.selected_idx = 0
+                  self.scroll_offset = 0
+                  self.selections = {'chat_model': None, 'chat_provider': None}
+                  self.status = "Detecting..."
+
+          state = SetupState()
+
+          def get_size():
+              try:
+                  s = os.get_terminal_size()
+                  return s.columns, s.lines
+              except:
+                  return 80, 24
+
+          def get_all_models():
+              return state.local_models + state.cloud_models
+
+          def render_screen():
+              width, height = get_size()
+              out = []
+              out.append("\033[2J\033[H")
+              header = " NPCSH Setup Wizard "
+              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")
+
+              if state.phase == 'detect':
+                  out.append(f"\033[3;2H\033[1mDetected Providers:\033[0m")
+                  row = 5
+                  for provider, status in state.providers_status.items():
+                      icon = "\033[32m✓\033[0m" if status['available'] else "\033[31m✗\033[0m"
+                      count = f"({status['count']} models)" if status['count'] > 0 else "(not running)"
+                      out.append(f"\033[{row};4H{icon} {provider} {count}")
+                      row += 1
+                  row += 1
+                  out.append(f"\033[{row};2H\033[1mAPI Keys:\033[0m")
+                  row += 1
+                  for key in ['ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'GEMINI_API_KEY', 'DEEPSEEK_API_KEY']:
+                      present = state.api_keys.get(key, False)
+                      icon = "\033[32m✓\033[0m" if present else "\033[31m✗\033[0m"
+                      short_key = key.replace('_API_KEY', '').lower()
+                      out.append(f"\033[{row};4H{icon} {short_key}")
+                      row += 1
+                  row += 2
+                  out.append(f"\033[{row};2H\033[33m{state.status}\033[0m")
+                  row += 2
+                  out.append(f"\033[{row};2HPress [Enter] to select model, [q] to quit")
+
+              elif state.phase == 'select_chat':
+                  out.append(f"\033[3;2H\033[1mSelect Default Chat Model:\033[0m")
+                  models = get_all_models()
+                  visible_height = height - 8
+                  visible = models[state.scroll_offset:state.scroll_offset + visible_height]
+                  for i, (provider, model) in enumerate(visible):
+                      row = 5 + i
+                      idx = i + state.scroll_offset
+                      if idx == state.selected_idx:
+                          out.append(f"\033[{row};4H\033[47;30m> {model} ({provider})\033[0m")
+                      else:
+                          out.append(f"\033[{row};4H  {model} \033[90m({provider})\033[0m")
+
+              out.append(f"\033[{height};1H\033[90m[j/k] Navigate  [Enter] Select  [q] Quit\033[0m")
+              sys.stdout.write(''.join(out))
+              sys.stdout.flush()
+
+          def handle_input(c):
+              if c == 'q':
+                  return False
+              if c == '\x1b':
+                  if select.select([sys.stdin], [], [], 0.05)[0]:
+                      c2 = sys.stdin.read(1)
+                      if c2 == '[':
+                          c3 = sys.stdin.read(1)
+                          if c3 == 'A' and state.phase == 'select_chat':
+                              state.selected_idx = max(0, state.selected_idx - 1)
+                              if state.selected_idx < state.scroll_offset:
+                                  state.scroll_offset = state.selected_idx
+                          elif c3 == 'B' and state.phase == 'select_chat':
+                              models = get_all_models()
+                              _, height = get_size()
+                              state.selected_idx = min(len(models) - 1, state.selected_idx + 1)
+                              visible_height = height - 8
+                              if state.selected_idx >= state.scroll_offset + visible_height:
+                                  state.scroll_offset = state.selected_idx - visible_height + 1
+                  return True
+              if c == 'k' and state.phase == 'select_chat':
+                  state.selected_idx = max(0, state.selected_idx - 1)
+                  if state.selected_idx < state.scroll_offset:
+                      state.scroll_offset = state.selected_idx
+              elif c == 'j' and state.phase == 'select_chat':
+                  models = get_all_models()
+                  _, height = get_size()
+                  state.selected_idx = min(len(models) - 1, state.selected_idx + 1)
+                  visible_height = height - 8
+                  if state.selected_idx >= state.scroll_offset + visible_height:
+                      state.scroll_offset = state.selected_idx - visible_height + 1
+              elif c == '\r' or c == '\n':
+                  if state.phase == 'detect':
+                      if get_all_models():
+                          state.phase = 'select_chat'
+                          state.selected_idx = 0
+                      else:
+                          return False
+                  elif state.phase == 'select_chat':
+                      models = get_all_models()
+                      if models and state.selected_idx < len(models):
+                          provider, model = models[state.selected_idx]
+                          state.selections['chat_model'] = model
+                          state.selections['chat_provider'] = provider
+                          from npcsh.config import set_npcsh_config_value
+                          set_npcsh_config_value('NPCSH_CHAT_MODEL', model)
+                          set_npcsh_config_value('NPCSH_CHAT_PROVIDER', provider)
+                      return False
+              return True
+
+          def run_detection():
+              state.status = "Detecting Ollama..."
+              render_screen()
+              ollama_models = detect_ollama_models()
+              state.providers_status['ollama'] = {'available': len(ollama_models) > 0, 'count': len(ollama_models)}
+              state.local_models.extend(ollama_models)
+
+              state.status = "Detecting LM Studio..."
+              render_screen()
+              lm_models = detect_lm_studio_models()
+              state.providers_status['lm_studio'] = {'available': len(lm_models) > 0, 'count': len(lm_models)}
+              state.local_models.extend(lm_models)
+
+              state.status = "Checking API keys..."
+              render_screen()
+              state.api_keys = detect_api_keys()
+              state.cloud_models = get_cloud_models(state.api_keys)
+
+              total = len(state.local_models) + len(state.cloud_models)
+              state.status = f"Found {total} models."
+
+          fd = sys.stdin.fileno()
+          old_settings = termios.tcgetattr(fd)
+
+          try:
+              tty.setcbreak(fd)
+              sys.stdout.write('\033[?25l')
+              run_detection()
+              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')
+              sys.stdout.write('\033[2J\033[H')
+              sys.stdout.flush()
+
+          if state.selections['chat_model']:
+              context['output'] = f"Setup complete! Model: {state.selections['chat_model']} ({state.selections['chat_provider']})"
+          else:
+              context['output'] = "Setup cancelled."

{npcsh-1.1.18.data → npcsh-1.1.19.data}/data/npcsh/npc_team/split_pane.jinx

@@ -1,4 +1,4 @@
-jinx_name: studio.split_pane
+jinx_name: studio_split_pane
 description: Split an existing pane to create a new pane alongside it.
 inputs:
 - paneId: "active"

{npcsh-1.1.18.data → npcsh-1.1.19.data}/data/npcsh/npc_team/switch_npc.jinx

@@ -1,4 +1,4 @@
-jinx_name: studio.switch_npc
+jinx_name: studio_switch_npc
 description: Switch the active NPC in a chat pane.
 inputs:
 - paneId: "active"

{npcsh-1.1.18.data → npcsh-1.1.19.data}/data/npcsh/npc_team/switch_tab.jinx

@@ -1,4 +1,4 @@
-jinx_name: studio.switch_tab
+jinx_name: studio_switch_tab
 description: Switch to a specific tab in a pane.
 inputs:
 - paneId: "active"

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

@@ -0,0 +1,223 @@
+jinx_name: "sync"
+description: "Sync npc_team files from the npcsh repo to ~/.npcsh/npc_team. Detects local modifications before overwriting."
+inputs:
+- force: ""
+- dry_run: ""
+- jinxs: ""
+- npcs: ""
+- ctx: ""
+- images: ""
+steps:
+  - name: "sync_npc_team"
+    engine: "python"
+    code: |
+      import os
+      import hashlib
+      import shutil
+      from pathlib import Path
+      from datetime import datetime
+
+      force = context.get('force', False)
+      dry_run = context.get('dry_run', False)
+      sync_jinxs = context.get('jinxs', False)
+      sync_npcs = context.get('npcs', False)
+      sync_ctx = context.get('ctx', False)
+      sync_images = context.get('images', False)
+
+      # Convert string flags to boolean
+      def to_bool(val):
+          if isinstance(val, bool):
+              return val
+          if isinstance(val, str):
+              return val.lower() in ('true', '1', 'yes', 'y')
+          return bool(val)
+
+      force = to_bool(force)
+      dry_run = to_bool(dry_run)
+      sync_jinxs = to_bool(sync_jinxs)
+      sync_npcs = to_bool(sync_npcs)
+      sync_ctx = to_bool(sync_ctx)
+      sync_images = to_bool(sync_images)
+
+      # If none specified, sync all
+      sync_all = not (sync_jinxs or sync_npcs or sync_ctx or sync_images)
+
+      def get_file_hash(filepath):
+          """Get MD5 hash of file contents."""
+          try:
+              with open(filepath, 'rb') as f:
+                  return hashlib.md5(f.read()).hexdigest()
+          except:
+              return None
+
+      def get_files_recursive(base_path, extensions=None):
+          """Get all files recursively, optionally filtered by extensions."""
+          files = []
+          for root, dirs, filenames in os.walk(base_path):
+              # Skip .git directories
+              dirs[:] = [d for d in dirs if d != '.git']
+              for filename in filenames:
+                  if filename.startswith('.'):
+                      continue
+                  if extensions and not any(filename.endswith(ext) for ext in extensions):
+                      continue
+                  full_path = Path(root) / filename
+                  rel_path = full_path.relative_to(base_path)
+                  files.append(rel_path)
+          return files
+
+      def do_sync():
+          # Find the npc_team directory from the installed npcsh package
+          import subprocess
+          repo_npc_team = None
+
+          result = subprocess.run(['pip', 'show', 'npcsh'], capture_output=True, text=True)
+          if result.returncode == 0:
+              location = None
+              editable_location = None
+              for line in result.stdout.split('\n'):
+                  if line.startswith('Location:'):
+                      location = Path(line.split(':', 1)[1].strip())
+                  elif line.startswith('Editable project location:'):
+                      editable_location = Path(line.split(':', 1)[1].strip())
+
+              # Prefer editable location if available
+              if editable_location:
+                  repo_npc_team = editable_location / "npcsh" / "npc_team"
+              elif location:
+                  repo_npc_team = location / "npcsh" / "npc_team"
+
+          if not repo_npc_team or not repo_npc_team.exists():
+              return f"Error: Could not find npcsh package npc_team directory. Is npcsh installed?"
+
+          local_npc_team = Path.home() / ".npcsh" / "npc_team"
+
+          if not local_npc_team.exists():
+              return f"Error: Local npc_team directory not found at {local_npc_team}"
+
+          # Build list of extensions to sync based on flags
+          sync_extensions = []
+          if sync_all or sync_npcs:
+              sync_extensions.append('.npc')
+          if sync_all or sync_ctx:
+              sync_extensions.append('.ctx')
+          if sync_all or sync_jinxs:
+              sync_extensions.append('.jinx')
+          if sync_all or sync_images:
+              sync_extensions.extend(['.png', '.jpg', '.jpeg'])
+
+          # Get files from repo
+          repo_files = get_files_recursive(repo_npc_team, sync_extensions)
+
+          output_lines = []
+          output_lines.append(f"Syncing from: {repo_npc_team}")
+          output_lines.append(f"Syncing to:   {local_npc_team}")
+
+          # Show what's being synced
+          sync_types = []
+          if sync_all:
+              sync_types.append("all")
+          else:
+              if sync_npcs: sync_types.append("npcs")
+              if sync_ctx: sync_types.append("ctx")
+              if sync_jinxs: sync_types.append("jinxs")
+              if sync_images: sync_types.append("images")
+          output_lines.append(f"Syncing: {', '.join(sync_types)}")
+
+          if dry_run:
+              output_lines.append("\n[DRY RUN - No changes will be made]\n")
+          output_lines.append("")
+
+          new_files = []
+          updated_files = []
+          modified_locally = []
+          unchanged_files = []
+
+          for rel_path in repo_files:
+              repo_file = repo_npc_team / rel_path
+              local_file = local_npc_team / rel_path
+
+              if not local_file.exists():
+                  new_files.append(rel_path)
+              else:
+                  repo_hash = get_file_hash(repo_file)
+                  local_hash = get_file_hash(local_file)
+
+                  if repo_hash == local_hash:
+                      unchanged_files.append(rel_path)
+                  else:
+                      # Check if local file is newer (possibly modified by user)
+                      repo_mtime = repo_file.stat().st_mtime
+                      local_mtime = local_file.stat().st_mtime
+
+                      if local_mtime > repo_mtime:
+                          modified_locally.append((rel_path, local_mtime, repo_mtime))
+                      else:
+                          updated_files.append(rel_path)
+
+          # Report findings
+          if new_files:
+              output_lines.append(f"New files to add ({len(new_files)}):")
+              for f in new_files:
+                  output_lines.append(f"  + {f}")
+              output_lines.append("")
+
+          if updated_files:
+              output_lines.append(f"Files to update ({len(updated_files)}):")
+              for f in updated_files:
+                  output_lines.append(f"  ~ {f}")
+              output_lines.append("")
+
+          if modified_locally:
+              output_lines.append(f"Locally modified files ({len(modified_locally)}):")
+              for f, local_t, repo_t in modified_locally:
+                  local_dt = datetime.fromtimestamp(local_t).strftime('%Y-%m-%d %H:%M')
+                  repo_dt = datetime.fromtimestamp(repo_t).strftime('%Y-%m-%d %H:%M')
+                  output_lines.append(f"  ! {f}")
+                  output_lines.append(f"      local: {local_dt}  repo: {repo_dt}")
+              if not force:
+                  output_lines.append("  (use --force to overwrite these)")
+              output_lines.append("")
+
+          if unchanged_files:
+              output_lines.append(f"Already up to date: {len(unchanged_files)} files")
+              output_lines.append("")
+
+          # Perform sync if not dry run
+          if not dry_run:
+              synced = 0
+              skipped = 0
+
+              # Sync new files
+              for rel_path in new_files:
+                  src = repo_npc_team / rel_path
+                  dst = local_npc_team / rel_path
+                  dst.parent.mkdir(parents=True, exist_ok=True)
+                  shutil.copy2(src, dst)
+                  synced += 1
+
+              # Sync updated files
+              for rel_path in updated_files:
+                  src = repo_npc_team / rel_path
+                  dst = local_npc_team / rel_path
+                  dst.parent.mkdir(parents=True, exist_ok=True)
+                  shutil.copy2(src, dst)
+                  synced += 1
+
+              # Handle locally modified files
+              for rel_path, _, _ in modified_locally:
+                  if force:
+                      src = repo_npc_team / rel_path
+                      dst = local_npc_team / rel_path
+                      shutil.copy2(src, dst)
+                      synced += 1
+                  else:
+                      skipped += 1
+
+              output_lines.append(f"Synced: {synced} files")
+              if skipped:
+                  output_lines.append(f"Skipped: {skipped} locally modified files")
+
+          return "\n".join(output_lines)
+
+      context['output'] = do_sync()