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

npcsh-1.1.16.data/data/npcsh/npc_team/open_browser.jinx

@@ -0,0 +1,43 @@
+jinx_name: open_browser
+description: |
+  Open a browser and navigate to a URL. The browser stays open for follow-up commands.
+  Use this to start browser automation.
+inputs:
+  - url:
+      description: "URL to navigate to"
+  - browser: "firefox"
+
+steps:
+  - name: open_browser
+    engine: python
+    code: |
+      from selenium import webdriver
+      from selenium.webdriver.firefox.service import Service as FirefoxService
+      from selenium.webdriver.chrome.service import Service as ChromeService
+      from webdriver_manager.firefox import GeckoDriverManager
+      from webdriver_manager.chrome import ChromeDriverManager
+      from npcpy.work.browser import set_driver
+      import uuid
+
+      url = context.get('url', '')
+      browser_type = context.get('browser', 'firefox').lower()
+
+      try:
+          if browser_type == 'chrome':
+              options = webdriver.ChromeOptions()
+              options.add_argument('--start-maximized')
+              driver = webdriver.Chrome(service=ChromeService(ChromeDriverManager().install()), options=options)
+          else:
+              options = webdriver.FirefoxOptions()
+              driver = webdriver.Firefox(service=FirefoxService(GeckoDriverManager().install()), options=options)
+              driver.maximize_window()
+
+          driver.get(url)
+
+          session_id = str(uuid.uuid4())[:8]
+          set_driver(session_id, driver)
+
+          output = "Browser opened. Session: {}. Navigated to: {}. Title: {}".format(session_id, url, driver.title)
+      except Exception as e:
+          import traceback
+          output = "Failed to open browser: {}\n{}".format(str(e), traceback.format_exc())

npcsh-1.1.16.data/data/npcsh/npc_team/paper_search.jinx

@@ -0,0 +1,101 @@
+jinx_name: paper_search
+description: Search for academic papers across multiple sources (Semantic Scholar, arXiv, local datasets)
+inputs:
+  - query: ""
+  - limit: 10
+  - source: "all"
+steps:
+  - name: search_papers
+    engine: python
+    code: |
+      import os
+      import time
+      import requests
+      import urllib.request
+      import urllib.parse
+      import xml.etree.ElementTree as ET
+
+      query = context.get('query', '')
+      limit = int(context.get('limit', 10))
+      source = context.get('source', 'all').lower()
+
+      if not query:
+          context['output'] = """Usage: /paper_search <query> [--limit N] [--source SOURCE]
+
+      Sources:
+        all    - Search all available sources (default)
+        s2     - Semantic Scholar only (requires S2_API_KEY)
+        arxiv  - arXiv only
+      """
+          exit()
+
+      all_results = []
+
+      # Semantic Scholar
+      if source in ['all', 's2']:
+          api_key = os.environ.get('S2_API_KEY')
+          if api_key:
+              try:
+                  url = "https://api.semanticscholar.org/graph/v1/paper/search"
+                  headers = {"x-api-key": api_key}
+                  params = {"query": query, "limit": limit, "fields": "title,abstract,authors,year,citationCount,url"}
+                  response = requests.get(url, headers=headers, params=params, timeout=30)
+                  response.raise_for_status()
+                  for paper in response.json().get('data', []):
+                      all_results.append({
+                          'source': 'Semantic Scholar',
+                          'title': paper.get('title', ''),
+                          'year': paper.get('year'),
+                          'citations': paper.get('citationCount', 0),
+                          'authors': [a.get('name', '') for a in paper.get('authors', [])],
+                          'abstract': paper.get('abstract', '')[:300] if paper.get('abstract') else '',
+                          'url': paper.get('url', '')
+                      })
+              except Exception as e:
+                  print(f"S2 error: {e}")
+
+      # arXiv
+      if source in ['all', 'arxiv']:
+          try:
+              base_url = "http://export.arxiv.org/api/query"
+              params = {"search_query": f"all:{query}", "max_results": limit}
+              url = f"{base_url}?{urllib.parse.urlencode(params)}"
+              with urllib.request.urlopen(url, timeout=30) as response:
+                  data = response.read().decode('utf-8')
+              root = ET.fromstring(data)
+              ns = {'atom': 'http://www.w3.org/2005/Atom'}
+              for entry in root.findall('atom:entry', ns):
+                  all_results.append({
+                      'source': 'arXiv',
+                      'title': entry.find('atom:title', ns).text.strip().replace('\n', ' '),
+                      'year': entry.find('atom:published', ns).text[:4],
+                      'citations': None,
+                      'authors': [a.find('atom:name', ns).text for a in entry.findall('atom:author', ns)],
+                      'abstract': entry.find('atom:summary', ns).text.strip()[:300],
+                      'url': entry.find('atom:id', ns).text
+                  })
+          except Exception as e:
+              print(f"arXiv error: {e}")
+
+      if not all_results:
+          context['output'] = f"No papers found for: {query}"
+          exit()
+
+      # Format output
+      results = []
+      for i, paper in enumerate(all_results[:limit], 1):
+          authors = ', '.join(paper['authors'][:3])
+          if len(paper['authors']) > 3:
+              authors += ' et al.'
+          year = paper.get('year', '?')
+          citations = f", {paper['citations']} citations" if paper.get('citations') else ""
+
+          results.append(f"{i}. [{paper['source']}] {paper['title']} ({year}{citations})")
+          results.append(f"   Authors: {authors}")
+          if paper['abstract']:
+              results.append(f"   Abstract: {paper['abstract']}...")
+          results.append(f"   URL: {paper['url']}")
+          results.append("")
+
+      context['output'] = f"Found {len(all_results)} papers:\n\n" + "\n".join(results)
+      context['papers'] = all_results

npcsh-1.1.16.data/data/npcsh/npc_team/paste.jinx

@@ -0,0 +1,134 @@
+jinx_name: paste
+description: Grabs content from clipboard (images or text) and saves/displays it. Use this when Ctrl+V paste doesn't work properly.
+inputs:
+- output_path:
+    default: ""
+    description: "Optional path to save image to. If empty, saves to temp file."
+steps:
+  - name: "paste_clipboard"
+    engine: "python"
+    code: |
+      import tempfile
+      import os
+      from datetime import datetime
+      import io
+
+      output_path = ({{ output_path | default("") | tojson }} or "").strip()
+      image_saved = False
+      text_content = None
+
+      # Try PIL/Pillow with ImageGrab first (works on most systems)
+      try:
+          from PIL import ImageGrab, Image
+
+          # Try to grab image from clipboard
+          img = ImageGrab.grabclipboard()
+
+          if img is not None:
+              if isinstance(img, Image.Image):
+                  # It's an image
+                  if output_path:
+                      save_path = os.path.expanduser(output_path)
+                  else:
+                      timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+                      fd, save_path = tempfile.mkstemp(suffix='.png', prefix=f'npcsh_paste_{timestamp}_')
+                      os.close(fd)
+
+                  img.save(save_path, 'PNG')
+                  file_size = os.path.getsize(save_path)
+
+                  if file_size > 1024 * 1024:
+                      size_str = f"{file_size / (1024*1024):.1f} MB"
+                  elif file_size > 1024:
+                      size_str = f"{file_size / 1024:.1f} KB"
+                  else:
+                      size_str = f"{file_size} bytes"
+
+                  output = f"Image saved to: {save_path} ({size_str}, {img.size[0]}x{img.size[1]})"
+                  context['pasted_image_path'] = save_path
+                  image_saved = True
+
+              elif isinstance(img, list):
+                  # It's a list of file paths (copied files)
+                  output = f"Clipboard contains {len(img)} file(s):\n" + "\n".join(img)
+                  context['pasted_files'] = img
+                  image_saved = True
+
+      except ImportError:
+          pass
+      except Exception as e:
+          # ImageGrab failed, try other methods
+          pass
+
+      # If no image, try to get text via tkinter
+      if not image_saved:
+          try:
+              import tkinter as tk
+
+              root = tk.Tk()
+              root.withdraw()
+
+              try:
+                  text_content = root.clipboard_get()
+              except tk.TclError:
+                  text_content = None
+
+              root.destroy()
+
+          except Exception as e:
+              pass
+
+      # If still nothing, try GTK
+      if not image_saved and text_content is None:
+          try:
+              import gi
+              gi.require_version('Gtk', '3.0')
+              from gi.repository import Gtk, Gdk, GdkPixbuf
+
+              clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
+
+              # Try image first
+              pixbuf = clipboard.wait_for_image()
+              if pixbuf:
+                  if output_path:
+                      save_path = os.path.expanduser(output_path)
+                  else:
+                      timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+                      fd, save_path = tempfile.mkstemp(suffix='.png', prefix=f'npcsh_paste_{timestamp}_')
+                      os.close(fd)
+
+                  pixbuf.savev(save_path, 'png', [], [])
+                  file_size = os.path.getsize(save_path)
+
+                  if file_size > 1024 * 1024:
+                      size_str = f"{file_size / (1024*1024):.1f} MB"
+                  elif file_size > 1024:
+                      size_str = f"{file_size / 1024:.1f} KB"
+                  else:
+                      size_str = f"{file_size} bytes"
+
+                  output = f"Image saved to: {save_path} ({size_str}, {pixbuf.get_width()}x{pixbuf.get_height()})"
+                  context['pasted_image_path'] = save_path
+                  image_saved = True
+              else:
+                  # Try text
+                  text_content = clipboard.wait_for_text()
+
+          except Exception as e:
+              pass
+
+      # Handle text content
+      if not image_saved and text_content:
+          line_count = text_content.count('\n') + 1
+          char_count = len(text_content)
+          context['pasted_text'] = text_content
+
+          if line_count > 10:
+              preview_lines = text_content.split('\n')[:10]
+              preview = '\n'.join(preview_lines)
+              output = f"Clipboard text ({line_count} lines, {char_count} chars):\n---\n{preview}\n... ({line_count - 10} more lines)\n---"
+          else:
+              output = f"Clipboard text ({line_count} lines, {char_count} chars):\n---\n{text_content}\n---"
+
+      elif not image_saved:
+          output = "Clipboard is empty or could not access clipboard.\nMake sure you have PIL/Pillow installed: pip install Pillow"

npcsh-1.1.16.data/data/npcsh/npc_team/plonk.npc

@@ -0,0 +1,27 @@
+name: plonk
+ascii_art: |
+  🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲
+  ██████  ██       ██████  ███    ██ ██   ██
+  ██   ██ ██      ██    ██ ████   ██ ██  ██
+  ██████  ██  🪵  ██    ██ ██ ██  ██ █████
+  ██      ██      ██    ██ ██  ██ ██ ██  ██
+  ██      ███████  ██████  ██   ████ ██   ██
+  🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲
+colors:
+  top: "34,139,34"
+  bottom: "139,69,19"
+primary_directive: |
+  You are plonk, the browser and GUI automation specialist.
+
+  Browser tools: open_browser, browser_action, browser_screenshot, close_browser
+
+  browser_action actions: click, type, type_and_enter, select, wait, scroll, get_text, get_page, get_elements, press_key
+
+  Use get_elements to discover selectors on the page. Use xpath:// prefix for XPath selectors.
+
+  Desktop tools: screenshot, click, type_text, key_press, launch_app, wait
+jinxs:
+  - lib/browser/*
+  - lib/computer_use/*
+  - lib/core/sh
+  - lib/core/python

npcsh-1.1.16.data/data/npcsh/npc_team/plonkjr.npc

@@ -0,0 +1,23 @@
+name: plonkjr
+ascii_art: |
+  🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲
+  ██████  ██       ██████  ███    ██ ██   ██  🪵   ██ ██████
+  ██   ██ ██      ██    ██ ████   ██ ██  ██        ██ ██   ██
+  ██████  ██      ██    ██ ██ ██  ██ █████    🌲   ██ ██████
+  ██      ██      ██    ██ ██  ██ ██ ██  ██       ██  ██   ██
+  ██      ███████  ██████  ██   ████ ██   ██   █████  ██   ██
+  🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲🌲
+colors:
+  top: "34,139,34"
+  bottom: "139,69,19"
+primary_directive: |
+  You are plonkjr, the junior automation assistant. You handle basic computer use tasks:
+  taking screenshots, clicking, typing, and pressing keys. You're simpler than plonk -
+  you focus on executing the core actions without complex vision-based planning.
+  Just do what's asked: screenshot, click, type, key press.
+jinxs:
+  - lib/computer_use/screenshot
+  - lib/computer_use/click
+  - lib/computer_use/type_text
+  - lib/computer_use/key_press
+  - lib/core/sh

npcsh-1.1.16.data/data/npcsh/npc_team/screenshot.jinx

@@ -0,0 +1,23 @@
+jinx_name: screenshot
+description: Capture a screenshot of the current screen
+inputs:
+  - output_path: null  # Optional path to save screenshot
+
+steps:
+  - name: capture_screenshot
+    engine: python
+    code: |
+      from npcpy.data.image import capture_screenshot
+
+      output_path = context.get('output_path')
+      messages = context.get('messages', [])
+
+      result = capture_screenshot(full=True)
+
+      if result and 'file_path' in result:
+          context['output'] = f"Screenshot saved to: {result['file_path']}"
+          context['screenshot_path'] = result['file_path']
+      else:
+          context['output'] = "Failed to capture screenshot"
+
+      context['messages'] = messages

{npcsh/npc_team/jinxs/utils → npcsh-1.1.16.data/data/npcsh/npc_team}/search.jinx

@@ -25,7 +25,8 @@ steps:
     code: |
       import os
       import traceback
-      
+      from npcpy.data.web import search_web
+
       # Access query from context
       query = context.get('query')
       if not query or not query.strip():

npcsh-1.1.16.data/data/npcsh/npc_team/semantic_scholar.jinx

@@ -0,0 +1,69 @@
+jinx_name: semantic_scholar
+description: Search Semantic Scholar for academic papers. Requires S2_API_KEY env var.
+inputs:
+  - query: ""
+  - limit: 10
+steps:
+  - name: search_s2
+    engine: python
+    code: |
+      import os
+      import time
+      import requests
+
+      query = context.get('query', '')
+      limit = int(context.get('limit', 10))
+
+      if not query:
+          context['output'] = "Usage: /semantic_scholar <query> [--limit N]"
+          exit()
+
+      api_key = os.environ.get('S2_API_KEY')
+      if not api_key:
+          context['output'] = "Error: S2_API_KEY environment variable not set. Get one at https://www.semanticscholar.org/product/api"
+          exit()
+
+      url = "https://api.semanticscholar.org/graph/v1/paper/search"
+      headers = {"x-api-key": api_key}
+      params = {
+          "query": query,
+          "limit": limit,
+          "fields": "title,abstract,authors,year,citationCount,url,tldr"
+      }
+
+      try:
+          response = requests.get(url, headers=headers, params=params, timeout=30)
+          response.raise_for_status()
+          data = response.json().get('data', [])
+
+          if not data:
+              context['output'] = f"No papers found for: {query}"
+              exit()
+
+          results = []
+          for i, paper in enumerate(data, 1):
+              title = paper.get('title', 'No title')
+              year = paper.get('year', '?')
+              citations = paper.get('citationCount', 0)
+              authors = ', '.join([a.get('name', '') for a in paper.get('authors', [])[:3]])
+              if len(paper.get('authors', [])) > 3:
+                  authors += ' et al.'
+              abstract = paper.get('abstract', '')[:200] + '...' if paper.get('abstract') else 'No abstract'
+              tldr = paper.get('tldr', {}).get('text', '') if paper.get('tldr') else ''
+              url = paper.get('url', '')
+
+              results.append(f"{i}. {title} ({year})")
+              results.append(f"   Authors: {authors}")
+              results.append(f"   Citations: {citations}")
+              if tldr:
+                  results.append(f"   TL;DR: {tldr}")
+              else:
+                  results.append(f"   Abstract: {abstract}")
+              results.append(f"   URL: {url}")
+              results.append("")
+
+          context['output'] = f"Found {len(data)} papers:\n\n" + "\n".join(results)
+          context['papers'] = data
+
+      except requests.exceptions.RequestException as e:
+          context['output'] = f"Semantic Scholar API error: {e}"

{npcsh-1.1.14.data → npcsh-1.1.16.data}/data/npcsh/npc_team/sh.jinx

@@ -1,5 +1,5 @@
 jinx_name: sh
-description: Execute bash queries. Should be used to grep for file contents, list directories, explore information to answer user questions more practically.
+description: Execute bash queries. Should be used to grep for file contents, list directories, explore information to answer user questions more practically. NEVER use ls -R on directories that may contain node_modules, .git, or other large dependency folders - this will exceed token limits. Use targeted ls commands instead.
 inputs:
   - bash_command
 steps:
@@ -9,7 +9,7 @@ steps:
       import subprocess
       import os
 
-      cmd = '{{ bash_command }}'
+      cmd = {{ bash_command | tojson }}
       output = ""
 
       process = subprocess.Popen(
@@ -20,12 +20,6 @@ steps:
       )
       stdout, stderr = process.communicate()
 
-      # Only show debug output if NPCSH_DEBUG is set
-      if os.environ.get("NPCSH_DEBUG") == "1":
-          import sys
-          print(f"[sh] cmd: {cmd}", file=sys.stderr)
-          print(f"[sh] stdout: {stdout.decode('utf-8', errors='ignore')[:200]}", file=sys.stderr)
-
       if stderr:
           output = f"Error: {stderr.decode('utf-8')}"
       else:

npcsh-1.1.16.data/data/npcsh/npc_team/shh.jinx

@@ -0,0 +1,17 @@
+jinx_name: "shh"
+description: "Enable silent mode - only shows warnings and errors"
+inputs: []
+steps:
+  - name: "set_silent"
+    engine: "python"
+    code: |
+      state = context.get('state')
+      output_messages = context.get('messages', [])
+
+      if state:
+          result = state.set_log_level("silent")
+          context['output'] = result
+      else:
+          context['output'] = "Error: state not available"
+
+      context['messages'] = output_messages

npcsh-1.1.16.data/data/npcsh/npc_team/sibiji.npc

@@ -0,0 +1,24 @@
+name: sibiji
+ascii_art: |
+  🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️
+   ██████  ██  ██████  ██       ██  ██████  ██
+  ██       ██  ██   ██ ██       ██      ██  ██
+   █████   ██  ██████  ██  🕷️   ██      ██  ██
+       ██  ██  ██   ██ ██       ██  🕷️  ██  ██
+  ██████   ██  ██████  ██       ██  ██████  ██
+  🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️🕸️
+colors:
+  top: "148,0,211"
+  bottom: "75,0,130"
+primary_directive: |
+  You are sibiji, the orchestrator and general manager of the NPC team.
+  Your role is to delegate tasks to appropriate specialist agents based on their expertise.
+
+  When delegating, match the task to the agent whose primary_directive best fits.
+  You have access to the delegate tool to pass tasks to other agents.
+jinxs:
+  - lib/orchestration/delegate
+  - lib/orchestration/convene
+  - lib/core/sh
+  - lib/core/python
+  - lib/core/search

{npcsh-1.1.14.data → npcsh-1.1.16.data}/data/npcsh/npc_team/sql.jinx

@@ -8,7 +8,7 @@ steps:
   - engine: python
     code: |
       import pandas as pd
-      query = "{{ sql_query }}"
+      query = {{ sql_query | tojson }}
       try:
         df = pd.read_sql_query(query, npc.db_conn)
       except Exception as e:

npcsh-1.1.16.data/data/npcsh/npc_team/switch.jinx

@@ -0,0 +1,62 @@
+jinx_name: switch
+description: Get or set a switch in the .ctx file
+inputs:
+  - name: ""  # Switch name
+  - value: null  # Value to set (omit to get current value)
+  - scope: "workspace"  # "workspace" or "global"
+
+steps:
+  - name: manage_switch
+    engine: python
+    code: |
+      import os
+      import yaml
+      from pathlib import Path
+
+      switch_name = context.get('name', '')
+      switch_value = context.get('value')
+      scope = context.get('scope', 'workspace')
+      messages = context.get('messages', [])
+
+      if not switch_name:
+          context['output'] = "Usage: /switch <name> [value] [--scope workspace|global]"
+          context['messages'] = messages
+          exit()
+
+      # Determine .ctx path based on scope
+      if scope == "global":
+          ctx_path = Path.home() / ".npcsh" / "npc_team" / "npcsh.ctx"
+      else:
+          cwd = os.getcwd()
+          # Look for npc_team/*.ctx in workspace
+          npc_team_dir = Path(cwd) / "npc_team"
+          ctx_files = list(npc_team_dir.glob("*.ctx")) if npc_team_dir.exists() else []
+          ctx_path = ctx_files[0] if ctx_files else npc_team_dir / "team.ctx"
+
+      # Load existing ctx
+      ctx_data = {}
+      if ctx_path.exists():
+          try:
+              with open(ctx_path) as f:
+                  ctx_data = yaml.safe_load(f) or {}
+          except:
+              ctx_data = {}
+
+      # Ensure switches dict exists
+      if 'switches' not in ctx_data:
+          ctx_data['switches'] = {}
+
+      if switch_value is None:
+          # Get mode
+          current = ctx_data['switches'].get(switch_name, "not set")
+          context['output'] = f"{switch_name} ({scope}): {current}"
+      else:
+          # Set mode
+          ctx_path.parent.mkdir(parents=True, exist_ok=True)
+          ctx_data['switches'][switch_name] = switch_value
+          with open(ctx_path, 'w') as f:
+              yaml.dump(ctx_data, f, default_flow_style=False)
+          context['output'] = f"Set {switch_name} = {switch_value} ({scope})"
+
+      context['messages'] = messages
+      context['switch_value'] = ctx_data['switches'].get(switch_name)

npcsh-1.1.16.data/data/npcsh/npc_team/switches.jinx

@@ -0,0 +1,61 @@
+jinx_name: switches
+description: List all switches from .ctx files
+inputs:
+  - scope: "all"  # "workspace", "global", or "all"
+
+steps:
+  - name: list_switches
+    engine: python
+    code: |
+      import os
+      import yaml
+      from pathlib import Path
+
+      scope = context.get('scope', 'all')
+      messages = context.get('messages', [])
+
+      output_lines = []
+
+      # Global switches
+      if scope in ["global", "all"]:
+          global_ctx = Path.home() / ".npcsh" / "npc_team" / "npcsh.ctx"
+          if global_ctx.exists():
+              try:
+                  with open(global_ctx) as f:
+                      data = yaml.safe_load(f) or {}
+                  switches = data.get('switches', {})
+                  if switches:
+                      output_lines.append("Global switches:")
+                      for k, v in switches.items():
+                          output_lines.append(f"  {k}: {v}")
+                  else:
+                      output_lines.append("Global switches: (none)")
+              except:
+                  output_lines.append("Global switches: (none)")
+          else:
+              output_lines.append("Global switches: (none)")
+
+      # Workspace switches
+      if scope in ["workspace", "all"]:
+          cwd = os.getcwd()
+          npc_team_dir = Path(cwd) / "npc_team"
+          ctx_files = list(npc_team_dir.glob("*.ctx")) if npc_team_dir.exists() else []
+
+          if ctx_files:
+              try:
+                  with open(ctx_files[0]) as f:
+                      data = yaml.safe_load(f) or {}
+                  switches = data.get('switches', {})
+                  if switches:
+                      output_lines.append(f"Workspace switches:")
+                      for k, v in switches.items():
+                          output_lines.append(f"  {k}: {v}")
+                  else:
+                      output_lines.append("Workspace switches: (none)")
+              except:
+                  output_lines.append("Workspace switches: (none)")
+          else:
+              output_lines.append("Workspace switches: (none)")
+
+      context['output'] = "\n".join(output_lines) if output_lines else "No switches configured."
+      context['messages'] = messages