npcsh 0.1.2__py3-none-any.whl → 1.1.13__py3-none-any.whl

npcsh-1.1.13.data/data/npcsh/npc_team/guac.jinx

@@ -0,0 +1,317 @@
+jinx_name: guac
+description: Python data analysis mode - execute Python code with persistent locals, auto-load files
+inputs:
+  - model: null
+  - provider: null
+  - plots_dir: null
+
+steps:
+  - name: guac_repl
+    engine: python
+    code: |
+      import os
+      import sys
+      import io
+      import re
+      import traceback
+      from pathlib import Path
+      from datetime import datetime
+      from termcolor import colored
+
+      import numpy as np
+      import pandas as pd
+      import matplotlib.pyplot as plt
+
+      from npcpy.llm_funcs import get_llm_response
+      from npcpy.npc_sysenv import render_markdown, get_system_message
+
+      npc = context.get('npc')
+      team = context.get('team')
+      messages = context.get('messages', [])
+      plots_dir = context.get('plots_dir') or os.path.expanduser("~/.npcsh/plots")
+
+      model = context.get('model') or (npc.model if npc else None)
+      provider = context.get('provider') or (npc.provider if npc else None)
+
+      # Use shared_context for persistent Python locals
+      shared_ctx = npc.shared_context if npc and hasattr(npc, 'shared_context') else {}
+      if 'locals' not in shared_ctx:
+          shared_ctx['locals'] = {}
+
+      # Initialize locals with useful imports
+      guac_locals = shared_ctx['locals']
+      guac_locals.update({
+          'np': np,
+          'pd': pd,
+          'plt': plt,
+          'Path': Path,
+          'os': os,
+      })
+
+      # Also store dataframes reference
+      if 'dataframes' not in shared_ctx:
+          shared_ctx['dataframes'] = {}
+      guac_locals['dataframes'] = shared_ctx['dataframes']
+
+      os.makedirs(plots_dir, exist_ok=True)
+
+      print("""
+       ██████╗ ██╗   ██╗ █████╗  ██████╗
+      ██╔════╝ ██║   ██║██╔══██╗██╔════╝
+      ██║  ███╗██║   ██║███████║██║
+      ██║   ██║██║   ██║██╔══██║██║
+      ╚██████╔╝╚██████╔╝██║  ██║╚██████╗
+       ╚═════╝  ╚═════╝ ╚═╝  ╚═╝ ╚═════╝
+      """)
+
+      npc_name = npc.name if npc else "guac"
+      print(f"Entering guac mode (NPC: {npc_name}). Type '/gq' to exit.")
+      print("  - Type Python code directly to execute")
+      print("  - Type natural language to get code suggestions")
+      print("  - Drop file paths to auto-load data")
+      print(f"  - Plots saved to: {plots_dir}")
+
+      def is_python_code(text):
+          """Check if text looks like Python code"""
+          text = text.strip()
+          if not text:
+              return False
+          # Common Python patterns
+          if re.match(r'^(import |from |def |class |if |for |while |with |try:|@|#)', text):
+              return True
+          if re.match(r'^[a-zA-Z_][a-zA-Z0-9_]*\s*=', text):
+              return True
+          if re.match(r'^[a-zA-Z_][a-zA-Z0-9_]*\s*\(', text):
+              return True
+          if re.match(r'^[a-zA-Z_][a-zA-Z0-9_]*\s*\[', text):
+              return True
+          if text.startswith('print(') or text.startswith('plt.'):
+              return True
+          try:
+              compile(text, "<input>", "exec")
+              return True
+          except SyntaxError:
+              return False
+
+      def execute_python(code_str, locals_dict):
+          """Execute Python code and return output"""
+          output_capture = io.StringIO()
+          old_stdout, old_stderr = sys.stdout, sys.stderr
+
+          try:
+              sys.stdout = output_capture
+              sys.stderr = output_capture
+
+              # Try as expression first (for REPL-like behavior)
+              if '\n' not in code_str.strip():
+                  try:
+                      result = eval(compile(code_str, "<input>", "eval"), locals_dict)
+                      if result is not None:
+                          print(repr(result))
+                      return output_capture.getvalue().strip()
+                  except SyntaxError:
+                      pass
+
+              # Execute as statements
+              exec(compile(code_str, "<input>", "exec"), locals_dict)
+              return output_capture.getvalue().strip()
+
+          except Exception:
+              traceback.print_exc(file=output_capture)
+              return output_capture.getvalue().strip()
+          finally:
+              sys.stdout, sys.stderr = old_stdout, old_stderr
+
+      def auto_load_file(file_path, locals_dict):
+          """Auto-load a file into locals based on extension"""
+          path = Path(file_path).expanduser()
+          if not path.exists():
+              return None
+
+          ext = path.suffix.lower()
+          var_name = f"data_{datetime.now().strftime('%H%M%S')}"
+
+          try:
+              if ext == '.csv':
+                  df = pd.read_csv(path)
+                  locals_dict[var_name] = df
+                  shared_ctx['dataframes'][var_name] = df
+                  return f"Loaded CSV as '{var_name}': {len(df)} rows, {len(df.columns)} columns\nColumns: {list(df.columns)}"
+
+              elif ext in ['.xlsx', '.xls']:
+                  df = pd.read_excel(path)
+                  locals_dict[var_name] = df
+                  shared_ctx['dataframes'][var_name] = df
+                  return f"Loaded Excel as '{var_name}': {len(df)} rows, {len(df.columns)} columns"
+
+              elif ext == '.json':
+                  import json
+                  with open(path) as f:
+                      data = json.load(f)
+                  locals_dict[var_name] = data
+                  return f"Loaded JSON as '{var_name}': {type(data).__name__}"
+
+              elif ext in ['.png', '.jpg', '.jpeg', '.gif']:
+                  from PIL import Image
+                  img = Image.open(path)
+                  arr = np.array(img)
+                  locals_dict[f"{var_name}_img"] = img
+                  locals_dict[f"{var_name}_arr"] = arr
+                  return f"Loaded image as '{var_name}_img' and '{var_name}_arr': {img.size}"
+
+              elif ext == '.npy':
+                  arr = np.load(path)
+                  locals_dict[var_name] = arr
+                  return f"Loaded numpy array as '{var_name}': shape {arr.shape}"
+
+              elif ext in ['.txt', '.md']:
+                  with open(path) as f:
+                      text = f.read()
+                  locals_dict[var_name] = text
+                  return f"Loaded text as '{var_name}': {len(text)} chars"
+
+              else:
+                  with open(path, 'rb') as f:
+                      data = f.read()
+                  locals_dict[var_name] = data
+                  return f"Loaded binary as '{var_name}': {len(data)} bytes"
+
+          except Exception as e:
+              return f"Error loading {path}: {e}"
+
+      def save_current_plot():
+          """Save current matplotlib figure if any"""
+          if plt.get_fignums():
+              timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+              plot_path = os.path.join(plots_dir, f"plot_{timestamp}.png")
+              plt.savefig(plot_path, dpi=150, bbox_inches='tight')
+              plt.close()
+              return plot_path
+          return None
+
+      # Ensure system message for LLM help
+      if not messages or messages[0].get("role") != "system":
+          sys_msg = """You are a Python data analysis assistant. When the user asks questions:
+      1. Generate clean, executable Python code
+      2. Use pandas, numpy, matplotlib as needed
+      3. Reference variables already in the user's session
+      4. Keep code concise and focused"""
+          messages.insert(0, {"role": "system", "content": sys_msg})
+
+      # REPL loop
+      while True:
+          try:
+              prompt_str = f"{npc_name}:guac> "
+              user_input = input(prompt_str).strip()
+
+              if not user_input:
+                  continue
+
+              if user_input.lower() == "/gq":
+                  print("Exiting guac mode.")
+                  break
+
+              # /vars - show current variables
+              if user_input.lower() == "/vars":
+                  print(colored("Current variables:", "cyan"))
+                  for k, v in guac_locals.items():
+                      if not k.startswith('_') and k not in ['np', 'pd', 'plt', 'Path', 'os', 'dataframes']:
+                          vtype = type(v).__name__
+                          if isinstance(v, pd.DataFrame):
+                              print(f"  {k}: DataFrame ({len(v)} rows)")
+                          elif isinstance(v, np.ndarray):
+                              print(f"  {k}: ndarray {v.shape}")
+                          else:
+                              print(f"  {k}: {vtype}")
+                  continue
+
+              # /clear - clear variables
+              if user_input.lower() == "/clear":
+                  keep = {'np', 'pd', 'plt', 'Path', 'os', 'dataframes'}
+                  guac_locals.clear()
+                  guac_locals.update({k: v for k, v in [('np', np), ('pd', pd), ('plt', plt), ('Path', Path), ('os', os), ('dataframes', shared_ctx['dataframes'])]})
+                  print(colored("Variables cleared.", "yellow"))
+                  continue
+
+              # Check if it's a file path (drag & drop)
+              potential_path = user_input.strip("'\"")
+              if os.path.exists(os.path.expanduser(potential_path)):
+                  result = auto_load_file(potential_path, guac_locals)
+                  if result:
+                      print(colored(result, "green"))
+                  continue
+
+              # Check if it's Python code
+              if is_python_code(user_input):
+                  output = execute_python(user_input, guac_locals)
+                  if output:
+                      print(output)
+
+                  # Save any plots
+                  plot_path = save_current_plot()
+                  if plot_path:
+                      print(colored(f"Plot saved: {plot_path}", "green"))
+                  continue
+
+              # Natural language - ask LLM for code
+              # Include current variables in context
+              var_context = "Current variables:\n"
+              for k, v in guac_locals.items():
+                  if not k.startswith('_') and k not in ['np', 'pd', 'plt', 'Path', 'os', 'dataframes']:
+                      if isinstance(v, pd.DataFrame):
+                          var_context += f"  {k}: DataFrame with columns {list(v.columns)}\n"
+                      elif isinstance(v, np.ndarray):
+                          var_context += f"  {k}: ndarray shape {v.shape}\n"
+                      else:
+                          var_context += f"  {k}: {type(v).__name__}\n"
+
+              prompt = f"{var_context}\nUser request: {user_input}\n\nGenerate Python code to accomplish this. Return ONLY the code, no explanation."
+
+              resp = get_llm_response(
+                  prompt,
+                  model=model,
+                  provider=provider,
+                  messages=messages,
+                  npc=npc
+              )
+
+              messages = resp.get('messages', messages)
+              code_response = str(resp.get('response', ''))
+
+              # Extract code from response (strip markdown if present)
+              code = code_response
+              if '```python' in code:
+                  code = code.split('```python')[1].split('```')[0]
+              elif '```' in code:
+                  code = code.split('```')[1].split('```')[0]
+              code = code.strip()
+
+              if code:
+                  print(colored("Generated code:", "cyan"))
+                  print(code)
+                  confirm = input("Execute? [Y/n/e(dit)]: ").strip().lower()
+
+                  if confirm in ['', 'y', 'yes']:
+                      output = execute_python(code, guac_locals)
+                      if output:
+                          print(output)
+                      plot_path = save_current_plot()
+                      if plot_path:
+                          print(colored(f"Plot saved: {plot_path}", "green"))
+
+                  elif confirm == 'e':
+                      edited = input("Enter modified code: ").strip()
+                      if edited:
+                          output = execute_python(edited, guac_locals)
+                          if output:
+                              print(output)
+
+          except KeyboardInterrupt:
+              print("\nUse '/gq' to exit or continue.")
+              continue
+          except EOFError:
+              print("\nExiting guac mode.")
+              break
+
+      context['output'] = "Exited guac mode."
+      context['messages'] = messages

npcsh-1.1.13.data/data/npcsh/npc_team/help.jinx

@@ -0,0 +1,52 @@
+jinx_name: help
+description: Show help for commands, NPCs, or Jinxs
+inputs:
+  - topic: null
+steps:
+  - name: show_help
+    engine: python
+    code: |
+      import json
+      from npcsh._state import CANONICAL_ARGS, get_argument_help
+      
+      topic = context.get('topic')
+      
+      if not topic:
+          output_lines = ["# Available Commands\n\n"]
+          
+          all_jinxs = {}
+          if hasattr(npc, 'team') and npc.team and hasattr(npc.team, 'jinxs_dict'):
+              all_jinxs.update(npc.team.jinxs_dict)
+          if hasattr(npc, 'jinxs_dict') and npc.jinxs_dict:
+              all_jinxs.update(npc.jinxs_dict)
+          
+          for cmd in sorted(all_jinxs.keys()):
+              jinx_obj = all_jinxs[cmd]
+              desc = getattr(jinx_obj, 'description', 'No description')
+              output_lines.append(f"/{cmd} - {desc}\n\n")
+          
+          arg_help_map = get_argument_help()
+          if arg_help_map:
+              output_lines.append("## Common Command-Line Flags\n\n")
+              output_lines.append("The shortest unambiguous prefix works.\n")
+              
+              for arg in sorted(CANONICAL_ARGS):
+                  aliases = arg_help_map.get(arg, [])
+                  alias_str = f"(-{min(aliases, key=len)})" if aliases else ""
+                  output_lines.append(f"--{arg:<20} {alias_str}\n")
+          
+          output = "".join(output_lines)
+      else:
+          jinx_obj = None
+          if hasattr(npc, 'team') and npc.team and hasattr(npc.team, 'jinxs_dict'):
+              jinx_obj = npc.team.jinxs_dict.get(topic)
+          if not jinx_obj and hasattr(npc, 'jinxs_dict'):
+              jinx_obj = npc.jinxs_dict.get(topic)
+          
+          if jinx_obj:
+              output = f"## Help for Jinx: `/{topic}`\n\n"
+              output += f"- **Description**: {jinx_obj.description}\n"
+              if hasattr(jinx_obj, 'inputs') and jinx_obj.inputs:
+                  output += f"- **Inputs**: {json.dumps(jinx_obj.inputs, indent=2)}\n"
+          else:
+              output = f"No help topic found for `{topic}`."

npcsh-1.1.13.data/data/npcsh/npc_team/init.jinx

@@ -0,0 +1,41 @@
+jinx_name: "init"
+description: "Initialize NPC project"
+inputs:
+  - directory: "." # The directory where the NPC project should be initialized.
+  - templates: "" # Optional templates to use for initialization.
+  - context: "" # Optional context for project initialization.
+  - model: "" # Optional LLM model to set as default for the project.
+  - provider: "" # Optional LLM provider to set as default for the project.
+steps:
+  - name: "initialize_project"
+    engine: "python"
+    code: |
+      import os
+      import traceback
+      from npcpy.npc_compiler import initialize_npc_project
+      
+      directory = context.get('directory')
+      templates = context.get('templates')
+      context_param = context.get('context') # Renamed to avoid conflict with Jinx context
+      model = context.get('model')
+      provider = context.get('provider')
+      output_messages = context.get('messages', [])
+      
+      output_result = ""
+      try:
+          initialize_npc_project(
+              directory=directory,
+              templates=templates,
+              context=context_param, # Use the renamed context parameter
+              model=model,
+              provider=provider
+          )
+          output_result = f"NPC project initialized in {os.path.abspath(directory)}."
+      except NameError:
+          output_result = "Init function (initialize_npc_project) not available."
+      except Exception as e:
+          traceback.print_exc()
+          output_result = f"Error initializing project: {e}"
+      
+      context['output'] = output_result
+      context['messages'] = output_messages

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

@@ -0,0 +1,32 @@
+jinx_name: jinxs
+description: Show available jinxs for the current NPC/Team
+inputs: []
+steps:
+  - name: list_jinxs
+    engine: python
+    code: |
+      output_lines = ["Available Jinxs:\n"]
+      jinxs_listed = set()
+      
+      if hasattr(npc, 'team') and npc.team:
+          team = npc.team
+          
+          if hasattr(team, 'jinxs_dict') and team.jinxs_dict:
+              output_lines.append(f"\n--- Team Jinxs ---\n")
+              for name, jinx_obj in sorted(team.jinxs_dict.items()):
+                  desc = getattr(jinx_obj, 'description', 'No description available.')
+                  output_lines.append(f"- /{name}: {desc}\n")
+                  jinxs_listed.add(name)
+      
+      if hasattr(npc, 'jinxs_dict') and npc.jinxs_dict:
+          output_lines.append(f"\n--- NPC Jinxs for {npc.name} ---\n")
+          for name, jinx_obj in sorted(npc.jinxs_dict.items()):
+              if name not in jinxs_listed:
+                  desc = getattr(jinx_obj, 'description', 'No description available.')
+                  output_lines.append(f"- /{name}: {desc}\n")
+                  jinxs_listed.add(name)
+      
+      if not jinxs_listed:
+          output = "No jinxs available for the current context."
+      else:
+          output = "".join(output_lines)

npcsh-1.1.13.data/data/npcsh/npc_team/kadiefa.npc

@@ -0,0 +1,3 @@
+name: kadiefa
+primary_directive: |
+    You are kadiefa, the exploratory snow leopard. You love to find new paths and to explore hidden gems. You go into caverns no cat has ventured into before. You climb peaks that others call crazy. You are at the height of your power. Your role is to lead the way for users to explore complex research questions and to think outside of the box.

npcsh-1.1.13.data/data/npcsh/npc_team/load_file.jinx

@@ -0,0 +1,35 @@
+jinx_name: load_file
+description: Loads and returns the contents of a file using npcpy's file loaders
+inputs:
+- file_path
+steps:
+  - name: "load_file"
+    engine: "python"
+    code: |
+      import os
+      from npcpy.data.load import load_file_contents
+      
+      # Expand user path and get absolute path
+      file_path = os.path.expanduser("{{ file_path }}")
+      
+      # Check if file exists
+      if not os.path.exists(file_path):
+          output = f"Error: File not found at {file_path}"
+      else:
+          try:
+              # Load file contents using npcpy's loader
+              # Returns chunks by default with chunk_size=250
+              chunks = load_file_contents(file_path)
+              
+              # Join chunks back together for full content
+              if isinstance(chunks, list):
+                  if chunks and chunks[0].startswith("Error"):
+                      output = chunks[0]
+                  else:
+                      file_content = "\n".join(chunks)
+                      output = f"File: {file_path}\n\n{file_content}"
+              else:
+                  output = f"File: {file_path}\n\n{chunks}"
+                  
+          except Exception as e:
+              output = f"Error reading file {file_path}: {str(e)}"

npcsh-1.1.13.data/data/npcsh/npc_team/npc-studio.jinx

@@ -0,0 +1,77 @@
+jinx_name: "npc-studio"
+description: "Start npc studio"
+inputs:
+  - user_command: ""
+steps:
+  - name: "launch_npc_studio"
+    engine: "python"
+    code: |
+      import os
+      import subprocess
+      import sys
+      from pathlib import Path
+      import traceback
+      
+      NPC_STUDIO_DIR = Path.home() / ".npcsh" / "npc-studio"
+      
+      user_command = context.get('user_command')
+      output_messages = context.get('messages', [])
+      output_result = ""
+      
+      try:
+          if not NPC_STUDIO_DIR.exists():
+              os.makedirs(NPC_STUDIO_DIR.parent, exist_ok=True)
+              subprocess.check_call([
+                  "git", "clone",
+                  "https://github.com/npc-worldwide/npc-studio.git",
+                  str(NPC_STUDIO_DIR)
+              ])
+          else:
+              subprocess.check_call(
+                  ["git", "pull"],
+                  cwd=NPC_STUDIO_DIR
+              )
+          
+          subprocess.check_call(
+              ["npm", "install"], 
+              cwd=NPC_STUDIO_DIR
+          )
+          
+          req_file = NPC_STUDIO_DIR / "requirements.txt"
+          if req_file.exists():
+              subprocess.check_call([
+                  sys.executable, 
+                  "-m", 
+                  "pip", 
+                  "install", 
+                  "-r", 
+                  str(req_file)
+              ])
+          
+          backend = subprocess.Popen(
+              [sys.executable, "npc_studio_serve.py"],
+              cwd=NPC_STUDIO_DIR
+          )
+          
+          dev_server = subprocess.Popen(
+              ["npm", "run", "dev"],
+              cwd=NPC_STUDIO_DIR
+          )
+          
+          frontend = subprocess.Popen(
+              ["npm", "start"],
+              cwd=NPC_STUDIO_DIR
+          )
+          
+          output_result = (
+              f"NPC Studio started!\n"
+              f"Backend PID={backend.pid}, "
+              f"Dev Server PID={dev_server.pid}, "
+              f"Frontend PID={frontend.pid}"
+          )
+      except Exception as e:
+          traceback.print_exc()
+          output_result = f"Failed to start NPC Studio: {e}"
+      
+      context['output'] = output_result
+      context['messages'] = output_messages

npcsh-1.1.13.data/data/npcsh/npc_team/npcsh.ctx

@@ -0,0 +1,18 @@
+context: |
+    The npcsh NPC team is devoted to providing a safe and helpful
+    environment for users where they can work and be as successful as possible.
+    npcsh is a command-line tool that makes it easy for users to harness
+    the power of LLMs from a command line shell. npcsh is a command line toolkit consisting of several programs.
+databases:
+    - ~/npcsh_history.db
+mcp_servers:
+    - ~/.npcsh/mcp_server.py
+use_global_jinxs: true
+forenpc: sibiji
+preferences:
+    - If you come up with an idea, it is critical that you also provide a way to validate the idea.
+    - Never change function names unless requested. keep things idempotent.
+    - If plots are requested for python code, prefer to use matplotlib. Do not ever use seaborn.
+    - Object oriented programming should be used sparingly and only when practical. Otherwise, opt for functional implementations.
+    - Never write unit tests unless explicitly requested.
+    - If we want you to write tests, we mean we want you to write example use cases that show how the code works. 

npcsh-1.1.13.data/data/npcsh/npc_team/ots.jinx

@@ -0,0 +1,61 @@
+jinx_name: "ots"
+description: "Take screenshot and analyze with vision model. Usage: /ots <prompt>"
+inputs:
+  - prompt
+  - image_paths_args: ""
+  - vmodel: ""
+  - vprovider: ""
+steps:
+  - name: "analyze_screenshot_or_image"
+    engine: "python"
+    code: |
+      import os
+      import traceback
+      from npcpy.llm_funcs import get_llm_response
+      from npcpy.data.image import capture_screenshot
+      
+      user_prompt = context.get('prompt') or ""
+      image_paths_args_str = context.get('image_paths_args') or ""
+      vision_model = context.get('vmodel') or ""
+      vision_provider = context.get('vprovider') or ""
+      stream_output = context.get('stream') or False
+      api_url = context.get('api_url') or ""
+      api_key = context.get('api_key') or ""
+      output_messages = context.get('messages', [])
+      current_npc = context.get('npc')
+
+      image_paths = []
+      if image_paths_args_str.strip():
+          for img_path_arg in image_paths_args_str.split(','):
+              full_path = os.path.abspath(os.path.expanduser(img_path_arg.strip()))
+              if os.path.exists(full_path):
+                  image_paths.append(full_path)
+      
+      if not image_paths:
+          screenshot_info = capture_screenshot(full=False)
+          if screenshot_info and "file_path" in screenshot_info:
+              image_paths.append(screenshot_info["file_path"])
+              print(f"📸 Screenshot captured: {screenshot_info.get('filename', os.path.basename(screenshot_info['file_path']))}")
+
+      if not vision_model:
+          vision_model = getattr(current_npc, 'model', 'gemma3:4b')
+      
+      if not vision_provider:
+          vision_provider = getattr(current_npc, 'provider', 'ollama')
+
+      response_data = get_llm_response(
+          prompt=user_prompt,
+          model=vision_model,
+          provider=vision_provider,
+          messages=output_messages,
+          images=image_paths,
+          stream=stream_output,
+          npc=current_npc,
+          api_url=api_url or None,
+          api_key=api_key or None
+      )
+      
+      context['output'] = response_data.get('response', 'No response received')
+      context['messages'] = response_data.get('messages', output_messages)
+      context['model'] = vision_model
+      context['provider'] = vision_provider