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

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

@@ -0,0 +1,230 @@
+jinx_name: "sync"
+description: "Sync npc_team files from the npcsh repo to ~/.npcsh/npc_team. Detects local modifications before overwriting."
+inputs:
+  - force: "" # Use --force or -f to overwrite all files without prompting
+  - dry_run: "" # Use --dry-run or -d to preview changes without applying them
+  - jinxs: "" # Use --jinxs to sync only .jinx files
+  - npcs: "" # Use --npcs to sync only .npc files
+  - ctx: "" # Use --ctx to sync only .ctx files
+  - images: "" # Use --images to sync only image files (.png, .jpg, .jpeg)
+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)
+
+      # Find the repo npc_team directory
+      # Check common locations
+      possible_repo_paths = [
+          Path.home() / "npcww" / "npc-core" / "npcsh" / "npcsh" / "npc_team",
+          Path.home() / "npc-core" / "npcsh" / "npcsh" / "npc_team",
+          Path.home() / "repos" / "npcsh" / "npcsh" / "npc_team",
+          Path.home() / "Projects" / "npcsh" / "npcsh" / "npc_team",
+      ]
+
+      # Also check if we can find it via pip show
+      try:
+          import subprocess
+          result = subprocess.run(['pip', 'show', 'npcsh', '-f'], capture_output=True, text=True)
+          if result.returncode == 0:
+              for line in result.stdout.split('\n'):
+                  if line.startswith('Location:'):
+                      pip_path = Path(line.split(':', 1)[1].strip()) / "npcsh" / "npc_team"
+                      if pip_path.exists():
+                          possible_repo_paths.insert(0, pip_path)
+      except:
+          pass
+
+      repo_npc_team = None
+      for path in possible_repo_paths:
+          if path.exists() and path.is_dir():
+              repo_npc_team = path
+              break
+
+      local_npc_team = Path.home() / ".npcsh" / "npc_team"
+
+      if not repo_npc_team:
+          context['output'] = "Error: Could not find npcsh repo npc_team directory.\nSearched:\n" + "\n".join(f"  - {p}" for p in possible_repo_paths)
+          exit()
+
+      if not local_npc_team.exists():
+          context['output'] = f"Error: Local npc_team directory not found at {local_npc_team}"
+          exit()
+
+      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
+
+      # 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")
+
+      context['output'] = "\n".join(output_lines)

npcsh-1.1.15.data/data/npcsh/npc_team/teamviz.jinx

@@ -0,0 +1,205 @@
+jinx_name: teamviz
+description: "Visualize NPC team structure - NPCs, jinxs, and their relationships"
+inputs:
+  - team_path: ""
+  - save: ""
+
+steps:
+  - name: visualize_team
+    engine: python
+    code: |
+      import os
+      import yaml
+      from pathlib import Path
+      import matplotlib.pyplot as plt
+      import networkx as nx
+      from collections import defaultdict
+
+      team_path = context.get('team_path') or ''
+      save_path = context.get('save') or ''
+
+      # Find team path
+      if not team_path:
+          if os.path.exists('./npc_team'):
+              team_path = './npc_team'
+          elif os.path.exists(os.path.expanduser('~/.npcsh/npc_team')):
+              team_path = os.path.expanduser('~/.npcsh/npc_team')
+          else:
+              output = "No npc_team found. Specify team_path."
+              exit()
+
+      team_path = Path(team_path)
+
+      # Load NPCs
+      npcs = {}
+      for npc_file in team_path.glob("*.npc"):
+          try:
+              with open(npc_file, 'r') as f:
+                  data = yaml.safe_load(f)
+              npcs[npc_file.stem] = {
+                  'jinxs': data.get('jinxs', []),
+                  'directive': data.get('primary_directive', '')[:100],
+                  'model': data.get('model', ''),
+              }
+          except Exception as e:
+              print("Error loading {}: {}".format(npc_file, e))
+
+      # Load team context
+      team_name = "NPC Team"
+      forenpc = None
+      for ctx_file in team_path.glob("*.ctx"):
+          try:
+              with open(ctx_file, 'r') as f:
+                  ctx = yaml.safe_load(f)
+              team_name = ctx.get('name', team_name)
+              forenpc = ctx.get('forenpc')
+          except:
+              pass
+
+      # Discover all jinxs
+      jinxs_dir = team_path / "jinxs"
+      all_jinxs = {}
+      if jinxs_dir.exists():
+          for jinx_file in jinxs_dir.rglob("*.jinx"):
+              rel_path = jinx_file.relative_to(jinxs_dir)
+              jinx_name = jinx_file.stem
+              # Categorize by location
+              if 'bin' in str(rel_path):
+                  category = 'bin'
+              elif 'lib' in str(rel_path):
+                  parts = str(rel_path).split(os.sep)
+                  category = parts[1] if len(parts) > 1 else 'lib'
+              else:
+                  category = 'other'
+              all_jinxs[jinx_name] = {'path': str(rel_path), 'category': category}
+
+      # Build graph
+      G = nx.DiGraph()
+
+      # Add team node
+      G.add_node(team_name, type='team', size=3000)
+
+      # Add NPC nodes
+      for npc_name, npc_data in npcs.items():
+          node_type = 'forenpc' if npc_name == forenpc else 'npc'
+          G.add_node(npc_name, type=node_type, size=2000)
+          G.add_edge(team_name, npc_name, relation='has_npc')
+
+      # Track jinx usage
+      jinx_users = defaultdict(list)
+      npc_jinx_patterns = {}
+
+      for npc_name, npc_data in npcs.items():
+          patterns = npc_data.get('jinxs', [])
+          npc_jinx_patterns[npc_name] = patterns
+
+          # Resolve patterns to actual jinxs
+          for pattern in patterns:
+              pattern = str(pattern)
+              if '*' in pattern:
+                  # Glob pattern like lib/browser/*
+                  base = pattern.replace('/*', '').replace('*', '')
+                  for jname, jdata in all_jinxs.items():
+                      if base in jdata['path']:
+                          jinx_users[jname].append(npc_name)
+              else:
+                  # Exact match
+                  jname = pattern.split('/')[-1]
+                  if jname in all_jinxs:
+                      jinx_users[jname].append(npc_name)
+
+      # Add jinx nodes (only ones that are used)
+      jinx_categories = defaultdict(list)
+      for jname, users in jinx_users.items():
+          if jname in all_jinxs:
+              cat = all_jinxs[jname]['category']
+              jinx_categories[cat].append(jname)
+
+              # Size based on usage
+              size = 500 + len(users) * 200
+              G.add_node(jname, type='jinx', category=cat, size=size, users=len(users))
+
+              for user in users:
+                  G.add_edge(user, jname, relation='uses')
+
+      # Check for delegation relationships
+      for npc_name, npc_data in npcs.items():
+          directive = npc_data.get('directive', '').lower()
+          for other_npc in npcs.keys():
+              if other_npc != npc_name and other_npc in directive:
+                  if 'delegate' in directive:
+                      G.add_edge(npc_name, other_npc, relation='delegates_to')
+
+      # Create visualization
+      fig, ax = plt.subplots(1, 1, figsize=(16, 12))
+
+      # Layout
+      pos = nx.spring_layout(G, k=2, iterations=50, seed=42)
+
+      # Color map
+      color_map = {
+          'team': '#FF6B6B',
+          'forenpc': '#4ECDC4',
+          'npc': '#45B7D1',
+          'jinx': '#96CEB4',
+      }
+
+      # Draw by type
+      for node_type in ['team', 'forenpc', 'npc', 'jinx']:
+          nodes = [n for n, d in G.nodes(data=True) if d.get('type') == node_type]
+          sizes = [G.nodes[n].get('size', 1000) for n in nodes]
+          nx.draw_networkx_nodes(G, pos, nodelist=nodes, node_color=color_map[node_type],
+                                  node_size=sizes, alpha=0.9, ax=ax)
+
+      # Draw edges by type
+      delegate_edges = [(u, v) for u, v, d in G.edges(data=True) if d.get('relation') == 'delegates_to']
+      use_edges = [(u, v) for u, v, d in G.edges(data=True) if d.get('relation') == 'uses']
+      has_edges = [(u, v) for u, v, d in G.edges(data=True) if d.get('relation') == 'has_npc']
+
+      nx.draw_networkx_edges(G, pos, edgelist=has_edges, edge_color='#999', alpha=0.5, ax=ax)
+      nx.draw_networkx_edges(G, pos, edgelist=use_edges, edge_color='#96CEB4', alpha=0.3, ax=ax)
+      nx.draw_networkx_edges(G, pos, edgelist=delegate_edges, edge_color='#FF6B6B',
+                              width=2, style='dashed', ax=ax, arrows=True, arrowsize=20)
+
+      # Labels
+      nx.draw_networkx_labels(G, pos, font_size=8, font_weight='bold', ax=ax)
+
+      # Legend
+      legend_elements = [
+          plt.scatter([], [], c=color_map['team'], s=200, label='Team'),
+          plt.scatter([], [], c=color_map['forenpc'], s=200, label='ForeNPC'),
+          plt.scatter([], [], c=color_map['npc'], s=200, label='NPC'),
+          plt.scatter([], [], c=color_map['jinx'], s=200, label='Jinx'),
+      ]
+      ax.legend(handles=legend_elements, loc='upper left')
+
+      ax.set_title(team_name + " - Team Structure", fontsize=14, fontweight='bold')
+      ax.axis('off')
+
+      plt.tight_layout()
+
+      if save_path:
+          plt.savefig(save_path, dpi=150, bbox_inches='tight')
+          plt.close()
+          output = "Saved to " + save_path
+      else:
+          plt.show()
+          output = "Displayed team visualization"
+
+      # Text summary
+      summary = "\n\n--- Team Summary ---\n"
+      summary += "Team: {}\n".format(team_name)
+      summary += "ForeNPC: {}\n".format(forenpc or 'None')
+      summary += "NPCs ({}): {}\n".format(len(npcs), ', '.join(sorted(npcs.keys())))
+      summary += "Total Jinxs: {}\n".format(len(all_jinxs))
+      summary += "\nJinxs by category:\n"
+      for cat, jlist in sorted(jinx_categories.items()):
+          summary += "  {}: {} jinxs\n".format(cat, len(jlist))
+
+      summary += "\nMost shared jinxs:\n"
+      shared = sorted(jinx_users.items(), key=lambda x: len(x[1]), reverse=True)[:10]
+      for jname, users in shared:
+          if len(users) > 1:
+              summary += "  {} (used by {}): {}\n".format(jname, len(users), ', '.join(users))
+
+      output = output + summary

npcsh-1.1.15.data/data/npcsh/npc_team/type_text.jinx

@@ -0,0 +1,27 @@
+jinx_name: type_text
+description: Type text using keyboard
+inputs:
+  - text: ""  # Text to type
+
+steps:
+  - name: perform_type
+    engine: python
+    code: |
+      from npcpy.work.desktop import perform_action
+
+      text = context.get('text', '')
+      messages = context.get('messages', [])
+
+      if not text:
+          context['output'] = "Usage: /type_text <text to type>"
+          context['messages'] = messages
+          exit()
+
+      try:
+          perform_action({'type': 'type', 'text': text})
+          preview = text[:30] + "..." if len(text) > 30 else text
+          context['output'] = f"Typed: {preview}"
+      except Exception as e:
+          context['output'] = f"Type failed: {e}"
+
+      context['messages'] = messages

npcsh-1.1.15.data/data/npcsh/npc_team/verbose.jinx

@@ -0,0 +1,17 @@
+jinx_name: "verbose"
+description: "Enable verbose logging - shows debug output from npcpy"
+inputs: []
+steps:
+  - name: "set_verbose"
+    engine: "python"
+    code: |
+      state = context.get('state')
+      output_messages = context.get('messages', [])
+
+      if state:
+          result = state.set_log_level("verbose")
+          context['output'] = result
+      else:
+          context['output'] = "Error: state not available"
+
+      context['messages'] = output_messages

{npcsh/npc_team/jinxs/utils → npcsh-1.1.15.data/data/npcsh/npc_team}/vixynt.jinx

@@ -41,27 +41,15 @@ steps:
       except (ValueError, TypeError):
           width = 1024
       
-      # Get model and provider, prioritizing context, then NPC, then environment variables
+      # Get model and provider from context or environment
       model = context.get('model')
       provider = context.get('provider')
-      
-      # Use NPC's model/provider as fallback
-      if not model and npc and hasattr(npc, 'model') and npc.model:
-          model = npc.model 
-      if not provider and npc and hasattr(npc, 'provider') and npc.provider:
-          provider = npc.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')
-
-      # Final hardcoded fallbacks if nothing else is set
-      if not model:
-          model = "runwayml/stable-diffusion-v1-5"
-      if not provider:
-          provider = "diffusers"
       
       # Parse attachments
       input_images = []
@@ -93,12 +81,11 @@ steps:
                   images_list = result
               
               saved_files = []
-              html_image_tags = [] # This list will store the raw HTML <img> tags
-              
+
               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)))
@@ -111,25 +98,16 @@ steps:
                           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)
 
-                  # Convert image to base64 and create an HTML <img> tag
-                  with open(current_output_file, 'rb') as f:
-                      img_data = base64.b64encode(f.read()).decode()
-                      # Using raw HTML <img> tag with data URI
-                      html_image_tags.append(f'<img src="data:image/png;base64,{img_data}" alt="Generated Image {i+1}" style="max-width: 100%; display: block; margin-top: 10px;">')
-              
               if saved_files:
-                  output_text_message = f"Image(s) generated and saved to: {', '.join(saved_files)}"
+                  output = f"Image(s) generated: {', '.join(saved_files)}"
                   if input_images:
-                      output_text_message = f"Image(s) edited and saved to: {', '.join(saved_files)}"
-                  
-                  output = output_text_message # Keep the text message clean
-                  output += f"\n\nThe image files have been saved and are ready to view."
-                  output += "\n\n" + "\n".join(html_image_tags) # Append all HTML <img> tags to the output
+                      output = f"Image(s) edited: {', '.join(saved_files)}"
+                  context['generated_images'] = saved_files
               else:
                   output = "No images were generated."
                   

npcsh-1.1.15.data/data/npcsh/npc_team/wait.jinx

@@ -0,0 +1,21 @@
+jinx_name: wait
+description: Wait/pause for a specified duration in seconds
+inputs:
+  - duration: 1  # Duration to wait in seconds
+
+steps:
+  - name: perform_wait
+    engine: python
+    code: |
+      import time
+
+      duration = float(context.get('duration', 1))
+      messages = context.get('messages', [])
+
+      try:
+          time.sleep(duration)
+          context['output'] = f"Waited {duration} seconds"
+      except Exception as e:
+          context['output'] = f"Wait failed: {e}"
+
+      context['messages'] = messages