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

npcsh/npc_team/jinxs/utils/roll.jinx

@@ -0,0 +1,68 @@
+jinx_name: "roll"
+description: "Generate a video from a text prompt."
+inputs:
+  - prompt: "" # Required text prompt for video generation.
+  - vgmodel: "" # Video generation model to use. Defaults to NPCSH_VIDEO_GEN_MODEL or NPC's model.
+  - vgprovider: "" # Video generation provider to use. Defaults to NPCSH_VIDEO_GEN_PROVIDER or NPC's provider.
+  - num_frames: 125 # Number of frames for the video.
+  - width: 256 # Width of the video.
+  - height: 256 # Height of the video.
+  - output_path: "output.mp4" # Output file path for the video.
+steps:
+  - name: "generate_video"
+    engine: "python"
+    code: |
+      import traceback
+      from npcpy.llm_funcs import gen_video
+      # Assuming NPCSH_VIDEO_GEN_MODEL and NPCSH_VIDEO_GEN_PROVIDER are accessible
+      
+      prompt = context.get('prompt')
+      num_frames = int(context.get('num_frames', 125)) # Ensure int type
+      width = int(context.get('width', 256)) # Ensure int type
+      height = int(context.get('height', 256)) # Ensure int type
+      output_path = context.get('output_path')
+      video_gen_model = context.get('vgmodel')
+      video_gen_provider = context.get('vgprovider')
+      output_messages = context.get('messages', [])
+      current_npc = context.get('npc')
+      
+      if not prompt or not prompt.strip():
+          context['output'] = "Usage: /roll <your prompt>"
+          context['messages'] = output_messages
+          exit()
+
+      # Fallback for model/provider if not explicitly set in Jinx inputs
+      if not video_gen_model and current_npc and current_npc.model:
+          video_gen_model = current_npc.model
+      if not video_gen_provider and current_npc and current_npc.provider:
+          video_gen_provider = current_npc.provider
+      
+      # Final fallbacks (these would ideally come from npcsh._state config)
+      if not video_gen_model: 
+            video_gen_model = "stable-video-diffusion" # Example default
+      if not video_gen_provider: 
+            video_gen_provider = "diffusers" # Example default
+
+      try:
+          result = gen_video(
+              prompt=prompt,
+              model=video_gen_model,
+              provider=video_gen_provider,
+              npc=current_npc,
+              num_frames=num_frames,
+              width=width,
+              height=height,
+              output_path=output_path,
+              **context.get('api_kwargs', {}) # Assuming api_kwargs might be passed
+          )
+          
+          if isinstance(result, dict):
+              context['output'] = result.get('output', 'Video generated.')
+              context['messages'] = result.get('messages', output_messages)
+          else:
+              context['output'] = str(result)
+              context['messages'] = output_messages
+      except Exception as e:
+          traceback.print_exc()
+          context['output'] = f"Error generating video: {e}"
+          context['messages'] = output_messages

npcsh/npc_team/jinxs/utils/sample.jinx

@@ -0,0 +1,56 @@
+jinx_name: "sample"
+description: "Send a prompt directly to the LLM."
+inputs:
+  - prompt: "" # Required text prompt to send to the LLM.
+  - model: "" # LLM model to use. Defaults to NPC's model.
+  - provider: "" # LLM provider to use. Defaults to NPC's provider.
+steps:
+  - name: "send_prompt_to_llm"
+    engine: "python"
+    code: |
+      import traceback
+      from npcpy.llm_funcs import get_llm_response
+      
+      prompt = context.get('prompt')
+      llm_model = context.get('model')
+      llm_provider = context.get('provider')
+      output_messages = context.get('messages', [])
+      current_npc = context.get('npc')
+
+      if not prompt or not prompt.strip():
+          context['output'] = "Usage: /sample <your prompt> [-m --model] model  [-p --provider] provider"
+          context['messages'] = output_messages
+          exit()
+      
+      # Fallback for model/provider if not explicitly set in Jinx inputs
+      if not llm_model and current_npc and current_npc.model:
+          llm_model = current_npc.model
+      if not llm_provider and current_npc and current_npc.provider:
+          llm_provider = current_npc.provider
+      
+      # Final fallbacks (these would ideally come from npcsh._state config)
+      if not llm_model: llm_model = "gemini-1.5-pro" # Example default
+      if not llm_provider: llm_provider = "gemini" # Example default
+
+      try:
+          result = get_llm_response(
+              prompt=prompt,
+              model=llm_model,
+              provider=llm_provider,
+              npc=current_npc,
+              **{k:v for k,v in context.items() if k not in ['messages', 'prompt', 'model', 'provider']} # Pass other context
+          )
+          
+          if isinstance(result, dict):
+              context['output'] = result.get('response')
+              context['messages'] = result.get('messages', output_messages)
+              context['model'] = llm_model
+              context['provider'] = llm_provider
+          else:
+              context['output'] = str(result)
+              context['messages'] = output_messages
+      
+      except Exception as e:
+          traceback.print_exc()
+          context['output'] = f"Error sampling LLM: {e}"
+          context['messages'] = output_messages

npcsh/npc_team/jinxs/utils/search.jinx

@@ -0,0 +1,130 @@
+jinx_name: "search"
+description: >
+  Executes a search across various sources.
+  Usage:
+    /search <query>                         (Default: Web Search)
+    /search --memory <query>                (Search approved memories)
+    /search --kg <query>                    (Search the knowledge graph)
+    /search --rag [-f <paths>] <query>      (Execute a RAG search)
+    /search --brainblast <query>            (Advanced history search)
+inputs:
+  - query: ""
+  - sprovider: ""
+  - memory: false
+  - kg: false
+  - rag: false
+  - brainblast: false
+  - file_paths: ""
+  - history_db_path: "~/npcsh_history.db"
+  - vector_db_path: "~/npcsh_chroma.db"
+  - emodel: ""
+  - eprovider: ""
+steps:
+  - name: "execute_unified_search"
+    engine: "python"
+    code: |
+      import os
+      import traceback
+      
+      # Access query from context
+      query = context.get('query')
+      if not query or not query.strip():
+          context['output'] = "Usage: /search [--memory|--kg|--rag|--brainblast] <query>"
+      else:
+          # state is available as a GLOBAL variable (from extra_globals)
+          # Access it directly, not from context
+          try:
+              current_state = state  # This should work now
+          except NameError:
+              context['output'] = "Error: Shell state not available in jinx context"
+              raise
+          
+          current_npc = current_state.npc
+          current_team = current_state.team
+
+          npc_name = getattr(current_npc, 'name', '__none__') if current_npc else '__none__'
+          team_name = getattr(current_team, 'name', '__none__') if current_team else '__none__'
+          current_path = os.getcwd()
+          db_path = os.path.expanduser(context.get("history_db_path") or "~/.npcsh/npcsh_history.db")
+          
+          try:
+              cmd_history = CommandHistory(db_path)
+              
+              if context.get('memory'):
+                  memories = get_relevant_memories(
+                      command_history=cmd_history, 
+                      npc_name=npc_name, 
+                      team_name=team_name,
+                      path=current_path, 
+                      query=query, 
+                      max_memories=10, 
+                      state=current_state  # Pass the state object
+                  )
+                  print(memories)
+                  
+                  if not memories:
+                      output = f"No memories found for query: '{query}'"
+                  else:
+                      output = f"Found {len(memories)} memories:\n\n" + "\n".join(
+                          f"{i}. [{mem.get('timestamp', 'unknown')}] {mem.get('final_memory') or mem.get('initial_memory')}" 
+                          for i, mem in enumerate(memories, 1)
+                      )
+              
+              elif context.get('kg'):
+                  facts = search_kg_facts(
+                      cmd_history, 
+                      npc_name, 
+                      team_name, 
+                      current_path, 
+                      query
+                  )
+                  print(facts)
+                  
+                  if not facts:
+                      output = f"No KG facts found for query: '{query}'"
+                  else:
+                      output = f"Found {len(facts)} KG facts:\n\n" + "\n".join(
+                          f"{i}. {fact.get('statement')}" for i, fact in enumerate(facts, 1)
+                      )
+
+              elif context.get('rag'):
+                  file_paths_str = context.get('file_paths', '')
+                  file_paths = [os.path.abspath(os.path.expanduser(p.strip())) for p in file_paths_str.split(',') if p.strip()]
+                  emodel = context.get('emodel') or current_state.embedding_model
+                  eprovider = context.get('eprovider') or current_state.embedding_provider
+                  
+                  file_contents = []
+                  for path in file_paths:
+                      chunks = load_file_contents(path)
+                      basename = os.path.basename(path)
+                      file_contents.extend([f"{basename}: {chunk}" for chunk in chunks])
+
+                  result = execute_rag_command(
+                      command=query,
+                      vector_db_path=os.path.expanduser(context.get('vector_db_path') or "~/.npcsh/npcsh_chroma.db"),
+                      embedding_model=emodel,
+                      embedding_provider=eprovider,
+                      file_contents=file_contents or None
+                  )
+                  print(result)
+                  output = result.get('response', 'No response from RAG.')
+
+              elif context.get('brainblast'):
+                  result = execute_brainblast_command(
+                      command=query, 
+                      command_history=cmd_history, 
+                      **context
+                  )
+                  print(result)
+                  output = result.get('output', 'Brainblast search executed.')
+
+              else:
+                  # Default to web search
+                  provider = context.get('sprovider') or current_state.search_provider
+                  results = search_web(query, provider=provider)
+                  output = "\n".join([f"- {res}" for res in results]) if results else "No web results found."
+
+          except Exception as e:
+              output = f"An error occurred in the search jinx: {e}\n{traceback.format_exc()}"
+
+          context['output'] = output

npcsh/npc_team/jinxs/utils/serve.jinx

@@ -0,0 +1,26 @@
+jinx_name: "serve"
+description: "Serve an NPC Team"
+inputs:
+  - port: 5337 # The port to run the Flask server on.
+  - cors: "" # Comma-separated CORS origins.
+steps:
+  - name: "start_flask_server"
+    engine: "python"
+    code: |
+      from npcpy.serve import start_flask_server
+      
+      port = context.get('port')
+      cors_str = context.get('cors')
+      output_messages = context.get('messages', [])
+
+      cors_origins = None
+      if cors_str and cors_str.strip():
+          cors_origins = [origin.strip() for origin in cors_str.split(",")]
+
+      start_flask_server(
+          port=int(port), # Ensure port is an integer
+          cors_origins=cors_origins,
+      )
+
+      context['output'] = "NPC Team server started. Execution of this jinx will pause until the server is stopped."
+      context['messages'] = output_messages

npcsh/npc_team/jinxs/utils/sleep.jinx

@@ -0,0 +1,116 @@
+jinx_name: "sleep"
+description: "Evolve knowledge graph. Use --dream to also run creative synthesis."
+inputs:
+  - dream: False # Boolean flag to also run creative synthesis (dream process).
+  - ops: "" # Comma-separated list of operations to configure KG sleep process.
+  - model: "" # LLM model to use for KG evolution. Defaults to NPC's model.
+  - provider: "" # LLM provider to use for KG evolution. Defaults to NPC's provider.
+steps:
+  - name: "evolve_knowledge_graph"
+    engine: "python"
+    code: |
+      import os
+      import traceback
+      from npcpy.memory.command_history import CommandHistory, load_kg_from_db, save_kg_to_db
+      from npcpy.memory.knowledge_graph import kg_sleep_process, kg_dream_process
+      # Assuming render_markdown is available if needed for logging progress
+
+      is_dreaming = context.get('dream')
+      operations_str = context.get('ops')
+      llm_model = context.get('model')
+      llm_provider = context.get('provider')
+      output_messages = context.get('messages', [])
+      current_npc = context.get('npc')
+      current_team = context.get('team')
+
+      operations_config = None
+      if operations_str and isinstance(operations_str, str):
+          operations_config = [op.strip() for op in operations_str.split(',')]
+      
+      # Fallback for model/provider if not explicitly set in Jinx inputs
+      if not llm_model and current_npc and current_npc.model:
+          llm_model = current_npc.model
+      if not llm_provider and current_npc and current_npc.provider:
+          llm_provider = current_npc.provider
+      
+      # Final fallbacks (these would ideally come from npcsh._state config)
+      if not llm_model: llm_model = "gemini-1.5-pro" # Example default
+      if not llm_provider: llm_provider = "gemini" # Example default
+
+      team_name = current_team.name if current_team else "__none__"
+      npc_name = current_npc.name if isinstance(current_npc, type(None).__class__) else "__none__"
+      current_path = os.getcwd()
+      scope_str = f"Team: '{team_name}', NPC: '{npc_name}', Path: '{current_path}'"
+
+      # Assume render_markdown exists
+      # render_markdown(f"- Checking knowledge graph for scope: {scope_str}")
+
+      command_history = None
+      try:
+          db_path = os.getenv("NPCSH_DB_PATH", os.path.expanduser("~/npcsh_history.db"))
+          command_history = CommandHistory(db_path)
+          engine = command_history.engine
+      except Exception as e:
+          context['output'] = f"Error connecting to history database for KG access: {e}"
+          context['messages'] = output_messages
+          exit()
+
+      output_result = ""
+      try:
+          current_kg = load_kg_from_db(engine, team_name, npc_name, current_path)
+
+          if not current_kg or not current_kg.get('facts'):
+              output_msg = f"Knowledge graph for the current scope is empty. Nothing to process.\n"
+              output_msg += f"  - Scope Checked: {scope_str}\n\n"
+              output_msg += "**Hint:** Have a conversation or run some commands first to build up knowledge in this specific context. The KG is unique to each combination of Team, NPC, and directory."
+              context['output'] = output_msg
+              context['messages'] = output_messages
+              exit()
+
+          original_facts = len(current_kg.get('facts', []))
+          original_concepts = len(current_kg.get('concepts', []))
+          
+          process_type = "Sleep"
+          ops_display = f"with operations: {operations_config}" if operations_config else "with random operations"
+          # render_markdown(f"- Initiating sleep process {ops_display}")
+          
+          evolved_kg, _ = kg_sleep_process(
+              existing_kg=current_kg,
+              model=llm_model,
+              provider=llm_provider,
+              npc=current_npc,
+              operations_config=operations_config
+          )
+
+          if is_dreaming:
+              process_type += " & Dream"
+              # render_markdown(f"- Initiating dream process on the evolved KG...")
+              evolved_kg, _ = kg_dream_process(
+                  existing_kg=evolved_kg,
+                  model=llm_model,
+                  provider=llm_provider,
+                  npc=current_npc
+              )
+
+          save_kg_to_db(engine, evolved_kg, team_name, npc_name, current_path) # Changed conn to engine
+
+          new_facts = len(evolved_kg.get('facts', []))
+          new_concepts = len(evolved_kg.get('concepts', []))
+
+          output_result = f"{process_type} process complete.\n"
+          output_result += f"- Facts: {original_facts} -> {new_facts} ({new_facts - original_facts:+})\n"
+          output_result += f"- Concepts: {original_concepts} -> {new_concepts} ({new_concepts - original_concepts:+})"
+          
+          print('Evolved facts:', evolved_kg.get('facts'))
+          print('Evolved concepts:', evolved_kg.get('concepts'))
+          
+          context['output'] = output_result
+          context['messages'] = output_messages
+
+      except Exception as e:
+          traceback.print_exc()
+          context['output'] = f"Error during KG evolution process: {e}"
+          context['messages'] = output_messages
+      finally:
+          if command_history: # Check if it was successfully initialized
+              command_history.close()

npcsh/npc_team/jinxs/utils/trigger.jinx

@@ -0,0 +1,61 @@
+jinx_name: "trigger"
+description: "Creates a persistent listener (--listen) or a scheduled task (--cron)."
+inputs:
+  - listen: "" # The description for a persistent, event-driven listener.
+  - cron: ""   # The description for a scheduled, time-based task.
+steps:
+  - name: "execute_command"
+    engine: "python"
+    code: |
+      import traceback
+      from npcpy.work.trigger import execute_trigger_command # For --listen
+      from npcpy.work.plan import execute_plan_command      # For --cron
+      
+      listen_description = context.get('listen')
+      cron_description = context.get('cron')
+      output_messages = context.get('messages', [])
+      
+      USAGE = 'Usage: /trigger --listen "<description>" OR /trigger --cron "<description>"'
+      
+      # Determine which command was used and set the appropriate variables
+      subcommand = None
+      description = None
+      executor_func = None
+      
+      # --- Argument Validation ---
+      # Ensure mutual exclusivity
+      if listen_description and cron_description:
+          context['output'] = f"Error: --listen and --cron are mutually exclusive. {USAGE}"
+          context['messages'] = output_messages
+          exit()
+          
+      # --- Command Dispatch ---
+      if listen_description:
+          subcommand = 'listen'
+          description = listen_description
+          executor_func = execute_trigger_command
+      elif cron_description:
+          subcommand = 'cron'
+          description = cron_description
+          executor_func = execute_plan_command
+      else:
+          # Handle case where no arguments were provided
+          context['output'] = f"Error: You must provide either --listen or --cron. {USAGE}"
+          context['messages'] = output_messages
+          exit()
+      
+      # --- Execution ---
+      try:
+          result = executor_func(command=description, **context)
+          
+          if isinstance(result, dict):
+              output_key = 'Listener' if subcommand == 'listen' else 'Cron job'
+              context['output'] = result.get('output', f'{output_key} created successfully.')
+              context['messages'] = result.get('messages', output_messages)
+          else:
+              context['output'] = str(result)
+              context['messages'] = output_messages
+      except Exception as e:
+          traceback.print_exc()
+          context['output'] = f"Error creating {subcommand}: {e}"
+          context['messages'] = output_messages

npcsh/npc_team/jinxs/utils/usage.jinx

@@ -0,0 +1,33 @@
+jinx_name: usage
+description: Display current session token usage and cost
+inputs: []
+steps:
+  - name: show_usage
+    engine: python
+    code: |
+      state = context.get('state')
+      if not state:
+          output = "No state available"
+      else:
+          inp = getattr(state, 'session_input_tokens', 0)
+          out = getattr(state, 'session_output_tokens', 0)
+          cost = getattr(state, 'session_cost_usd', 0.0)
+          turns = getattr(state, 'turn_count', 0)
+          total = inp + out
+
+          def fmt(n):
+              return f"{n/1000:.1f}k" if n >= 1000 else str(n)
+
+          def fmt_cost(c):
+              if c == 0:
+                  return "free (local)"
+              elif c < 0.01:
+                  return f"${c:.4f}"
+              else:
+                  return f"${c:.2f}"
+
+          output = f"Session Usage\n"
+          output += f"Tokens: {fmt(inp)} in / {fmt(out)} out ({fmt(total)} total)\n"
+          output += f"Cost:   {fmt_cost(cost)}\n"
+          output += f"Turns:  {turns}"
+      context['output'] = output

npcsh/npc_team/jinxs/utils/vixynt.jinx

@@ -0,0 +1,144 @@
+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, prioritizing context, then NPC, then environment variables
+      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 = []
+      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 = []
+              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)))
+                      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)
+
+                  # 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)}"
+                  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
+              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/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/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/npc_team/plonk.npc

@@ -0,0 +1,2 @@
+name: plonk
+primary_directive: You are the superior automation specialist of the NPC team.